Encontré esta pregunta en SO y pensé que sería un buen desafío de golf. Asi que aqui esta:

Desafío:

Escriba un programa que lea una secuencia de cadenas de caracteres, una por línea, y genere una lista de todas las posiciones donde cada cadena tiene el mismo carácter.

Entrada y salida:

La entrada consta de una o más líneas de caracteres ASCII imprimibles sin espacios en blanco, cada uno seguido de una nueva línea. Usted puede asumir que todas las líneas de entrada tienen la misma longitud. La nueva línea no debe considerarse parte de la entrada (es decir, no debe salir como un carácter coincidente).

Ejemplo de entrada (descaradamente robado de la pregunta SO):

abcdefg
avcddeg
acbdeeg

Después de leer la entrada, su programa debe imprimir las posiciones de cada columna coincidente y los caracteres que contienen. (Su programa puede, pero no necesariamente, dejar de leer más entradas si puede determinar antes que no hay columnas coincidentes). Se permite cualquier formato de salida razonable; en particular, puede usar indexación basada en 0 o en 1 para las posiciones.

Ejemplo de salida para la entrada anterior (usando indexación basada en 0):

0: a
3: d
6: g

Puntuación:

Este es el código de golf, por lo que gana la respuesta más corta. En caso de empate, se pueden otorgar caracteres fraccionarios de desempate por características adicionales:

• −½ caracteres para manejar correctamente las líneas de entrada de longitud desigual. (La salida no debe contener posiciones más allá del final de la línea de entrada más corta).
• −¼ caracteres para manejar correctamente la entrada que consiste en caracteres Unicode codificados UTF-8 arbitrarios.

Para inspirarte, puedes encontrar algunas soluciones no protegidas en la pregunta SO (ver arriba).

Aclaraciones:

• Simplemente concatenar las posiciones y los caracteres, como en 0a3d6g, no cuenta como "salida razonable". Debe proporcionar algún tipo de separador (como un espacio) entre cada elemento de la salida para que pueda analizarse sin ambigüedades.

• La entrada se proporcionará en la secuencia de entrada estándar ( stdin), o utilizando cualquier mecanismo de entrada de archivo de texto que sea más natural para el idioma que elija. (Si el idioma elegido no tiene un mecanismo natural para la entrada de archivos, haga lo que parezca más cercano en espíritu).

• La entrada finaliza cuando no hay más datos para leer (es decir, cuando se produce una condición de fin de archivo). Si lo desea, puede requerir que la entrada se termine con una línea en blanco (que luego no debe contar como parte de la entrada, obviamente). Si lo hace, menciónelo en su respuesta para que otros puedan proporcionar información correcta para la prueba.

• Cada línea de entrada, incluida la última, termina con un carácter de nueva línea. Su respuesta no debe informar esta nueva línea como una columna coincidente. (Está bien si su solución también puede manejar la entrada donde la última línea no termina en una nueva línea, pero eso no es necesario).

APL, 25 caracteres

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

Usé Dyalog APL (versión 13) como mi intérprete. Maneja entradas de longitud desigual y caracteres Unicode (UTF-8).

Ejemplos:

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

  1 a  4 d  7 g  

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

  4 t  5 日  6 本 

Explicación, algo de derecha a izquierda:

• La parte principal de esta respuesta es la función directa (básicamente, la función anónima), definida dentro de las llaves. Su argumento correcto está especificado por ⍵.
  • 0=⍴⍵:⍬es nuestra primera expresión, y verifica si hemos obtenido una línea vacía (es decir, hemos terminado). Utiliza un protector (una construcción familiar para muchos programadores funcionales) para ejecutar condicionalmente la expresión a la derecha del colon. En este caso, si 0 es igual a la forma / longitud ( ⍴) del argumento correcto, devolvemos el conjunto vacío ( ⍬).
  • ⋄separa las dos expresiones dentro de la función. Si la expresión anterior no fue evaluada (y por lo tanto no devolvió nada), pasamos a la siguiente expresión.
  • Llamamos recursivamente a la función usando la función de autorreferencia ( ∇). El argumento de la función es una línea de entrada del usuario no evaluada, dada por quote-quad ( ⍞).
  • ⊂⍵,⍨¨⍳⍴⍵ crea pares para cada carácter en la cadena, donde el primer elemento de cada par es su posición en la cadena, y su segundo elemento es el carácter.
  • ⍳⍴⍵da un vector de 1 a ⍴⍵, o la longitud de la cadena de entrada.
  • ⍵,⍨¨aplica la función de concatenación conmutada ( ,⍨) a cada ¨elemento ( ) a su izquierda ( ⍵, en este caso, la entrada del usuario) y derecha. Al conmutar la función de concatenación, se intercambian sus argumentos izquierdo y derecho.
  • Finalmente, adjuntamos el resultado usando ⊂, para que podamos diferenciar entre líneas de entrada.
• Inicialmente alimentamos nuestra función con la entrada del usuario ( ⍞).
• Finalmente, reducimos ( /) nuestro vector resultante de vectores de pares usando la función de intersección ( ∩), produciendo los pares que se encuentran en todos los sub-vectores.

Golfscript (28 caracteres)

n/zip:^,,{.^=.&.,1>{;;}*}%n*

Hay problemas con el juego de caracteres al pasar Unicode, por lo que no hay bonificación de cuarto de punto.

J, 57 51 44 40 caracteres

,.&.>y;y{{.z[y=.I.*/2=/\]z=.];._2]1!:1]3

Llego allí lenta pero seguramente. Esto todavía está lejos de ser ideal, aunque creo.

Estaba seguro de que usar un gancho sería la respuesta, pero desafortunadamente no (44 caracteres):

,.&.>((];({{.)~)([:I.[:*/2=/\]))];._2]1!:1]3

Es posible que necesite un método completamente diferente para acortarme.

Haskell, 64 personajes

main=interact$show.foldl1(filter.flip elem).map(zip[0..]).lines

Maneja líneas de longitud desigual. El soporte Unicode depende de la configuración regional actual.

Salida de ejemplo:

[(0,'a'),(3,'d'),(6,'g')]

Python 2, puntaje 81.5 ( 116 94 86 83 82 bytes menos bono)

import sys
i=0
for x in zip(*sys.stdin)[:-1]:
 i+=1
 if len(set(x))<2:print i,x[0]

(Bash) Shell Scripting, 105 caracteres

Si alguien tiene más trucos para esto, ¡no dudes en comentar!

for((i=1;i<`tail -1 $1|wc -c`;i++))do
x="cut -c$i $1";y=`$x`;[ `$x|uniq|wc -l` = 1 ]&& echo $i ${y:3};done

Resultado:

1 a
4 d
7 g

Perl, 87 caracteres (−½ char bonus de desempate)

Aquí hay una versión de golf de mi propia solución del hilo SO :

chomp($a=$b=<>);$a&=$_,$b|=$_ for<>;@$_=$$_=~/./sgfor a,b;$b[$i++]eq$_&&say"$i:$_"for@a

A diferencia de la versión SO, esta utiliza índices basados ​​en 1 para la salida. Utiliza la función Perl 5.10 say, por lo que debe ejecutarse con perl -M5.010(o con perl -E).

Al igual que la versión es así, esto manijas de código de líneas de longitud variable, y se manejan de entrada Unicode arbitraria si la entrada y la salida estándar eran en modo UTF-8. Lamentablemente, por defecto no lo son, a menos que uno especifique el cambio de línea de comando no libre -CS . Por lo tanto, gana el bono de ½ ½ char, pero no el −¼.

Editar: +1 char para corregir un error: solo porque las cadenas de entrada no contienen saltos de línea no significa que no puedan terminar en $a(por ejemplo "+" & "J" eq "\n").

T-SQL

SELECT N.number, letter = MIN(SUBSTRING(L.line, N.number, 1))
FROM Lines AS L
INNER JOIN master.dbo.spt_values AS N ON N.type = 'P'
WHERE N.number BETWEEN 1 AND (SELECT MAX(LEN(L2.line)) FROM Lines AS L2)
GROUP BY N.number
HAVING COUNT(DISTINCT SUBSTRING(L.line, N.number, 1)) = 1
ORDER BY N.number

Scala 115 107: (−¼ para manejar UTF-8)

io.Source.stdin.getLines.map(_.zipWithIndex).toList.flatten.groupBy(_._2).map(_._2.toSet).filter(_.size==1)

sin golf, y en Source.fromFile ("f")lugar de stdinuna mejor capacidad de prueba :

io.Source.fromFile ("f").
  getLines.map (_.zipWithIndex).
    toList.flatten.groupBy (_._2). 
      map (_._2.toSet).
        filter (_.size==1)

Resultado:

List(Set((a,0)), Set((g,6)), Set((d,3)))

Gracias a Gareth por la reducción del tamaño 8 por usar stdin.

VBA ( 307.25 284 - 0.75 bonus = 283.25)

Sé que esto ya se ganó, pero aquí está mi oportunidad (no leer un archivo, solo una cadena, necesita tener el io agregado). Me gusta que tengo que usar l()recursivamente. Por lo general, no tengo necesidad de recurrencia en mi programación de la vida real. Solo hice muchas pruebas, pero creo que esto cubre la estipulación de puntos de bonificación Unicode. También supone que vbCres el terminador de línea. Esto puede no traducirse a todos los sistemas por eso.

Código:

Function a(i)
b=Split(Left(i,Len(i)-1),vbCr):c=UBound(b):For q=1 To Len(b(c)):d=Mid(b(c),q,1):If l(b,c,q,d) Then a=a & q & ": " & d & vbCr:Next
End Function
Function l(m, n, o, p)
If n+1 Then l=IIf(o<=Len(m(n)),Mid(m(n),o,1)=p,0) And l(m,n-1,o,p) Else l=Mid(m(n+1),o,1)=p
End Function

Ejemplo de entrada / salida:

Debug.Print a("abcdefghijklmnop" & vbCr & "abcdefg" & vbCr & "abcabcghijkl" & vbCr)

1: a
2: b
3: c
7: g

Q, 32

{a!((*:)x)a:(&)1=(#:')(?:')(+)x}

uso

q){a!((*:)x)a:(&)1=(#:')(?:')(+)x}[("abcdefg";"avcddeg";"acbdeeg")]
0| a
3| d
6| g

K, 22

La solución anterior se puede reducir a 22 escribiéndola completamente en K en lugar de pasar las funciones de K a un intérprete de Q, reduciendo el número de paréntesis requeridos.

{a!@[*x]a:&1=#:'?:'+x}

PHP, 123 127 :(

No estoy contento con eso (seguramente habrá mejoras), pero aquí va:

<?$a=$b=trim(fgets(STDIN));while($l=fgets(STDIN)){$a&=$l;$b|=$l;}$n=-1;while(@$a[++$n]){echo$a[$n]!=$b[$n]?'':"$n:{$a[$n]}\n";}

Prueba de que funciona.

Si alguien puede pensar en una forma más inteligente de inicializar $ ay $ b, hágamelo saber. Originalmente tenía $a=$b=$n=''y $ b finalmente fue correcto, pero [empty] & [anything] == [empty]$ a nunca tuvo contenido.

Editar: Tuve que arreglar el manejo de nueva línea (+6) pero se cayó la etiqueta de cierre (-2).

JavaScript ( 125134 140 )

for(i=s=[];I=s[++i]=prompt(o='');S=I);for(c=-1;w=r=++c<S.length;o+=r?c+':'+C+'\n':'')for(C=S[c];w<i;)r&=s[w++][c]==C;alert(o)

Demostración: http://jsfiddle.net/Fv7kY/4/

Edición 1 : reorganice los bucles para evitar llaves. Inicialice i con []para combinar con s. Mueve el wincremento a la expresión.

Editar 2 : Permite S=Icapturar la última palabra ingresada y guardar usando s[1]. Combinar r=1y ++c<S.length. Establezca C=s[c]en el bucle interno y compare en Clugar de las palabras anteriores y siguientes para acortar la expresión s[w][c]==s[w++][c]a solo s[w++][c]==C. Guardado un total de 9 caracteres. También se establece w=r=...porque cuando eso es cierto, w=1es con lo que necesitamos inicializar w.

Rubí (71)

a,*s=*$<.lines
(a.size-1).times{|i|s.all?{|t|t[i]==a[i]}&&p([i,a[i]])}

salida:

[0, "a"]
[3, "d"]
[6, "g"]

Lisp común, 183 165 caracteres

(let((l(loop for m =(read-line)until(equal m "")collect m)))(loop for c across(car l)for i from 0 if(null(remove c(mapcar(lambda(y)(char y i))l)))collect(list i c)))

Formato legible:

(let ((l (loop for m = (read-line) until (equal m "") collect m)))
  (loop for c across (car l)
        for i from 0 
        if (null (remove c 
                         (mapcar (lambda(y) (char y i))l)))
        collect(list i c)))

Ingrese esto directamente en REPL e ingrese las líneas, terminando con una línea vacía.

C, 126 caracteres

char a[999],b[999];main(i){for(gets(a);gets(b);)for(i=0;b[i];++i)a[i]^b[i]?a[i]=0:0;
while(i--)a[i]&&printf("%d:%c\n",i,a[i]);}

He estado mirando esto, pero no puedo hacerlo más pequeño. Puede ser necesario un nuevo enfoque.

(Sin puntos de bonificación; solo maneja líneas de diferente tamaño si la primera línea es la más corta).

C # con .NET 4 (280)

using c=System.Console;class P{static void Main(){char[]a=c.ReadLine().ToCharArray();int r,i,l=a.Length;m:i=0;n:r=c.Read();if(r>0&&r!=10&&r!=13){if((int)a[i]!=r)a[i]='\0';i++;goto n;}for(;i>0&&i<l;)a[i++]='\0';if(r>0)goto m;for(i=0;i<l;i++)if(a[i]!='\0')c.WriteLine(i+":"+a[i]);}}

• 1 línea, 280 caracteres
• Incluye todo lo necesario usando declaraciones y método principal.
• El programa no requiere una línea vacía al final, pero lo aceptará
• Las líneas vacías se ignoran.
• Maneja cadenas de entrada de cualquier longitud.
• Reserva la salida hasta el final (mientras que la respuesta original proporcionó salida incremental)

Versión legible

    char[]a=c.ReadLine().ToCharArray();
    int r,i,l=a.Length;
    m:
    i=0;
    n:
    r=c.Read();
    if(r>0&&r!=10&&r!=13){
        if((int)a[i]!=r)
            a[i]='\0';
        i++;
        goto n;
    }
    for(;i>0&&i<l;)
        a[i++]='\0';
    if(r>0)
        goto m;
    for(i=0;i<l;i++)
        if(a[i]!='\0')
            c.WriteLine(i+":"+a[i]);

Respuesta original

usando c = System.Console; clase P {static void Main () {char [] a; var b = c.ReadLine (); a = b.ToCharArray (); while (b! = "") {for (int i = 0; i

• 1 linea
• 207 caracteres
• Incluye todo lo necesario usando declaraciones y método principal.
• El programa finaliza cuando se ingresa una línea vacía.
• No maneja cadenas de entrada que son más cortas que la primera.

    static void Readable()
    {
        char[]a;
        string b=System.Console.ReadLine();
        a=b.ToCharArray();
        while(b.Length>0)
        {
            for (int i = 0; i < a.Length; i++)
            {
                if (a[i] != b[i])
                {
                    a[i] = '\0';
                }
                else
                {
                    System.Console.WriteLine(i+": "+a[i]);
                }
            }
            b=System.Console.ReadLine();
        }
    }

Python 122 caracteres :

print("\n".join([str(i)+':'+str(x[0]) for i,x in enumerate(zip(*[tuple(x) for x in input().split()])) if len(set(x))<2]))

Rubí (242)

s = %w{ abcdefg avcddeg acbdeeg aejdjeggd }
cols = []
s.sort{ |a, b| b.size <=> a.size }[0].size.times do |i|
  uneq=true
  l = s[0][i]
  s.each { |w| uneq = false if l != w[i] }
  cols << [l, i] if uneq
end
cols.each { |c| puts c.join('|') }

C#

List<string> strings = new List<string> { "abcdefg", "avcddeg", "acbdeeg", "aejdjeggd" };
var transposes = from index in Enumerable.Range(0, strings.First().Length)
                 select new string((from s in strings select s[index]).ToArray());
int i = 0;
foreach(string transpose in transposes)
{
   if (transpose.Distinct().Count() == 1)
     Console.WriteLine("{0}: {1}", i , transpose[0]);
   i++;
}