Me deparei com esta pergunta no SO e pensei que seria um bom desafio para o golfe. Então aqui está:

Desafio:

Escreva um programa que leia uma sequência de cadeias de caracteres, uma por linha, e produza uma lista de todas as posições em que cada cadeia possui o mesmo caractere.

Entrada e saída:

A entrada consiste em uma ou mais linhas de caracteres ASCII sem espaço em branco imprimíveis, cada uma seguida por uma nova linha. Você pode supor que todas as linhas de entrada tenham o mesmo comprimento. A nova linha não deve ser considerada parte da entrada (ou seja, você não deve produzi-la como um caractere correspondente).

Exemplo de entrada (roubado descaradamente da pergunta SO):

abcdefg
avcddeg
acbdeeg

Depois de ler a entrada, seu programa deve imprimir as posições de cada coluna correspondente e os caracteres que eles contêm. (Seu programa pode, mas não precisa, parar de ler mais informações se puder determinar antecipadamente que não há colunas correspondentes.) Qualquer formato de saída razoável é permitido; em particular, você pode usar a indexação com base em 0 ou em 1 para as posições.

Exemplo de saída para a entrada acima (usando indexação baseada em 0):

0: a
3: d
6: g

Pontuação:

Isso é código de golfe, então a resposta mais curta vence. Em caso de empate, os caracteres fracionários do desempate podem ser concedidos por recursos adicionais:

• −½ caracteres para manipular corretamente linhas de entrada de comprimento desigual. (A saída não deve conter posições além do final da linha de entrada mais curta.)
• - chars para manipular corretamente a entrada que consiste em caracteres Unicode codificados UTF-8 arbitrários.

Para inspiração, você pode encontrar algumas soluções não destruídas na pergunta SO (veja acima).

Esclarecimentos:

• Simplesmente concatenar as posições e os caracteres, como em 0a3d6g, não conta como "resultado razoável". Você deve fornecer algum tipo de separador (como um espaço) entre cada elemento da saída, para que ele possa ser analisado sem ambiguidade.

• A entrada será fornecida no fluxo de entrada padrão ( stdin), ou usando qualquer mecanismo de entrada de arquivo de texto mais natural para o seu idioma de escolha. (Se o idioma escolhido não tiver um mecanismo natural para a entrada de arquivos, faça o que parecer mais próximo em espírito.)

• A entrada termina quando não há mais dados a serem lidos (ou seja, quando ocorre uma condição de fim de arquivo). Se desejar, você pode exigir que a entrada seja finalizada por uma linha em branco (que você então não deve contar como parte da entrada, obviamente). Se você fizer isso, mencione-o na sua resposta para que outras pessoas possam fornecer a entrada correta para o teste.

• Cada linha de entrada, incluindo a última, termina com um caractere de nova linha. Sua resposta não deve relatar esta nova linha como uma coluna correspondente. (Tudo bem se sua solução também puder manipular entradas onde a última linha não termina em uma nova linha, mas isso não é necessário.)

APL, 25 caracteres

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

Usei o Dyalog APL (versão 13) como intérprete. Ele lida com entradas de comprimento desigual e caracteres Unicode (UTF-8).

Exemplos:

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

  1 a  4 d  7 g  

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

  4 t  5 日  6 本 

Explicação, um pouco da direita para a esquerda:

• O principal pedaço desta resposta é a função direta (basicamente, função anônima), definida dentro dos chavetas. Seu argumento correto é especificado por ⍵.
  • 0=⍴⍵:⍬é a nossa primeira expressão e verifica se obtivemos uma linha vazia (ou seja, terminamos). Ele usa uma proteção (uma construção familiar para muitos programadores funcionais) para executar condicionalmente a expressão à direita dos dois pontos. Nesse caso, se 0 for igual à forma / comprimento ( ⍴) do argumento correto, retornamos o conjunto vazio ( ⍬).
  • ⋄separa as duas expressões dentro da função. Se a expressão anterior não foi avaliada (e, portanto, não retornou nada), passamos para a próxima expressão.
  • Chamamos recursivamente a função usando a função de auto-referência ( ∇). O argumento para a função é uma linha de entrada do usuário não avaliada, fornecida por quote-quad ( ⍞).
  • ⊂⍵,⍨¨⍳⍴⍵ cria pares para cada caractere na sequência, onde o primeiro elemento de cada par é sua posição na sequência e seu segundo elemento é o caractere.
  • ⍳⍴⍵fornece um vetor de 1 a ⍴⍵ou o comprimento da sequência de entrada.
  • ⍵,⍨¨aplica a função de concatenação comutada ( ,⍨) a cada ¨elemento ( ) à sua esquerda ( ⍵neste caso, a entrada do usuário) e à direita. A comutação da função de concatenação faz com que seus argumentos esquerdo e direito sejam trocados.
  • Finalmente, incluímos o resultado usando ⊂, para que possamos diferenciar as linhas de entrada.
• Inicialmente, alimentamos nossa função com a entrada do usuário ( ⍞).
• Finalmente, reduzimos ( /) nosso vetor resultante de vetores de pares usando a função de interseção ( ∩), produzindo os pares encontrados em todos os subvectores.

Golfscript (28 caracteres)

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

Há problemas no conjunto de caracteres ao canalizar Unicode, portanto, nenhum bônus de um quarto de ponto.

J, 57 51 44 40 caracteres

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

Estou chegando devagar, mas com segurança. Ainda está longe de ser o ideal, eu acho.

Eu tinha certeza de que usar um gancho seria a resposta, mas infelizmente não (44 caracteres):

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

Talvez eu precise de um método completamente diferente para diminuir.

Haskell, 64 caracteres

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

Lida com linhas de comprimento desigual. O suporte a Unicode depende das configurações atuais de localidade.

Exemplo de saída:

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

Python 2, pontuação 81,5 ( 116 94 86 83 82 bytes menos bônus)

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

Script de shell (Bash), 105 caracteres

Se alguém tiver mais alguns truques para isso, preencha gratuitamente para 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 (½ bônus de desempate de char)

Aqui está uma versão em golfe da minha própria solução a partir do thread SO :

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

Ao contrário da versão SO, este usa índices baseados em 1 para a saída. Ele usa o sayrecurso Perl 5.10 , portanto, precisa ser executado com perl -M5.010(ou com perl -E).

Tal como na versão Assim, este código de alças linhas de comprimento variável, e iria manipular a entrada arbitrária Unicode se a entrada e a saída padrão foram em modo UTF-8. Infelizmente, por padrão, não são, a menos que se especifique a opção de linha de comando não livre -CS . Assim, ele ganha o bônus de ½½, mas não o −¼.

Edit: +1 char para corrigir um erro: apenas porque as seqüências de entrada não contêm feeds de linha não significa que elas não podem terminar $a(por exemplo "+" & "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 manipulação de UTF-8)

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

ungolfed, e em Source.fromFile ("f")vez de stdinpara melhor testabilidade:

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)))

Agradecimentos a Gareth pela redução do tamanho 8 pelo uso stdin.

VBA ( 307,25 284 - bônus de 0,75 = 283,25)

Eu sei que isso já foi ganho, mas aqui está a minha chance (não ler um arquivo, apenas uma string - precisa ter o io adicionado). Eu gosto que tenho que usar l()recursivamente. Normalmente, não preciso recursar minha programação da vida real. Eu fiz apenas tantos testes, mas acredito que isso cobre a estipulação de pontos de bônus unicode. Também assumevbCr é o terminador de linha. Isso pode não ser traduzido para todos os sistemas por causa disso.

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

Exemplo de entrada / saída:

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

A solução acima pode ser reduzida para 22 escrevendo-a completamente em K em vez de passar as funções K para um intérprete Q, reduzindo o número de parênteses necessários.

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

PHP, 123 127 :(

Não estou feliz com isso (certamente haverá melhorias a serem feitas), mas aqui vai:

<?$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";}

Prova de que funciona.

Se alguém puder pensar em uma maneira mais inteligente de inicializar $ a e $ b, informe-me. Originalmente, eu tinha $a=$b=$n=''e $ b finalmente estava correto, mas [empty] & [anything] == [empty], portanto, $ a nunca teve conteúdo.

Editar: teve que corrigir o tratamento de nova linha (+6), mas deixou cair a marca de fechamento (-2).

JavaScript (125 134 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)

Demonstração: http://jsfiddle.net/Fv7kY/4/

Edição 1 : Reorganize os loops para evitar chaves. Inicialize i com []para combinar com s. Mova o wincremento para a expressão.

Editar 2 : defina S=Ipara capturar a última palavra digitada e salvar usando s[1]. Combine r=1e ++c<S.length. Defina C=s[c]no loop interno e compare com Cas palavras anteriores e próximas, para reduzir a expressão s[w][c]==s[w++][c]para apenas s[w++][c]==C. Guardou um total de 9 caracteres. Também definido w=r=...porque quando isso é verdade, w=1é com isso que precisamos inicializar w.

Rubi (71)

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

resultado:

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

Lisp comum, 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 legível:

(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)))

Digite isso diretamente no REPL e insira linhas, terminando com uma linha vazia.

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]);}

Eu estive encarando isso, mas simplesmente não posso torná-lo menor. Uma nova abordagem pode ser necessária.

(Sem pontos de bônus; ele só lida com linhas de tamanhos diferentes se a primeira linha for a mais curta.)

C # com .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 linha, 280 caracteres
• Inclui todas as instruções de uso necessárias e o método Principal.
• O programa não requer uma linha vazia no final, mas a aceitará
• Linhas vazias são ignoradas
• Manipula cadeias de entrada de qualquer comprimento.
• Reserva a saída até o final (enquanto a resposta original forneceu saída incremental)

Versão legível

    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]);

Resposta original

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

• 1 linha
• 207 caracteres
• Inclui todas as instruções de uso necessárias e o método Principal.
• O programa termina quando uma linha vazia é inserida.
• Não manipula seqüências de entrada mais curtas que a primeira.

    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]))

Rubi (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++;
}