Je suis tombé sur cette question sur SO et j'ai pensé que cela ferait un beau défi de golf. Voici donc:

Défi:

Écrivez un programme qui lit une séquence de chaînes de caractères, une par ligne, et génère une liste de toutes les positions où chaque chaîne a le même caractère.

Entrée et sortie:

L'entrée consiste en une ou plusieurs lignes de caractères ASCII non blancs imprimables, chacune suivie d'une nouvelle ligne. Vous pouvez supposer que toutes les lignes d'entrée ont la même longueur. La nouvelle ligne ne doit pas être considérée comme faisant partie de l'entrée (c'est-à-dire que vous ne devez pas la sortir en tant que caractère correspondant).

Exemple d'entrée (sans vergogne volé à la question SO):

abcdefg
avcddeg
acbdeeg

Après avoir lu l'entrée, votre programme doit imprimer les positions de chaque colonne correspondante et les caractères qu'elles contiennent. (Votre programme peut, mais pas nécessairement, arrêter de lire d'autres entrées s'il peut déterminer tôt qu'il n'y a pas de colonnes correspondantes.) Tout format de sortie raisonnable est autorisé; en particulier, vous pouvez utiliser une indexation basée sur 0 ou 1 pour les positions.

Exemple de sortie pour l'entrée ci-dessus (en utilisant l'indexation basée sur 0):

0: a
3: d
6: g

Notation:

C'est le golf de code, donc la réponse la plus courte l'emporte. En cas d'égalité, des caractères de bris d'égalité fractionnaires peuvent être attribués pour des fonctionnalités supplémentaires:

• −½ caractères pour gérer correctement les lignes d'entrée de longueur inégale. (La sortie ne doit pas contenir de positions après la fin de la ligne d'entrée la plus courte.)
• −¼ caractères pour gérer correctement l'entrée composée de caractères Unicode codés UTF-8 arbitraires.

Pour vous inspirer, vous pouvez trouver des solutions non golfées à la question SO (voir ci-dessus).

Clarifications:

• La simple concaténation des positions et des caractères, comme dans 0a3d6g, ne compte pas comme "sortie raisonnable". Vous devez fournir une sorte de séparateur (tel qu'un espace) entre chaque élément de la sortie afin qu'il puisse être analysé sans ambiguïté.

• L'entrée sera fournie sur le flux d'entrée standard ( stdin), ou en utilisant le mécanisme d'entrée de fichier texte le plus naturel pour la langue de votre choix. (Si la langue que vous avez choisie n'a pas de mécanisme naturel pour la saisie de fichiers, faites ce qui vous semble le plus proche dans l'esprit.)

• L'entrée se termine lorsqu'il n'y a plus de données à lire (c'est-à-dire lorsqu'une condition de fin de fichier se produit). Si vous le souhaitez, vous pouvez exiger que l'entrée soit terminée par une ligne vierge (que vous ne devez alors pas compter comme partie de l'entrée, évidemment). Si vous le faites, veuillez le mentionner dans votre réponse afin que d'autres puissent fournir une entrée correcte pour les tests.

• Chaque ligne d'entrée, y compris la dernière, se termine par un caractère de nouvelle ligne. Votre réponse ne doit pas signaler cette nouvelle ligne comme colonne correspondante. (Ce n'est pas grave si votre solution peut également gérer des entrées où la dernière ligne ne se termine pas par une nouvelle ligne, mais ce n'est pas obligatoire.)

APL, 25 caractères

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

J'ai utilisé Dyalog APL (version 13) comme interprète. Il gère à la fois les entrées de longueur inégale et les caractères Unicode (UTF-8).

Exemples:

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

  1 a  4 d  7 g  

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

  4 t  5 日  6 本 

Explication, un peu de droite à gauche:

• Le morceau principal de cette réponse est la fonction directe (fondamentalement, la fonction anonyme), définie entre les accolades. Son argument de droite est spécifié par ⍵.
  • 0=⍴⍵:⍬est notre première expression, et il vérifie si nous avons obtenu une ligne vide (c'est-à-dire que nous avons terminé). Il utilise un garde (une construction familière à de nombreux programmeurs fonctionnels) pour exécuter conditionnellement l'expression à droite des deux-points. Dans ce cas, si 0 est égal à la forme / longueur ( ⍴) de l'argument de droite, nous renvoyons l'ensemble vide ( ⍬).
  • ⋄sépare les deux expressions au sein de la fonction. Si l'expression précédente n'a pas été évaluée (et n'a donc rien renvoyé), nous passons à l'expression suivante.
  • Nous appelons récursivement la fonction en utilisant la fonction d'auto-référence ( ∇). L'argument de la fonction est une ligne d'entrée utilisateur non évaluée, donnée par quote-quad ( ⍞).
  • ⊂⍵,⍨¨⍳⍴⍵ crée des paires pour chaque caractère de la chaîne, où le premier élément de chaque paire est sa position dans la chaîne et son deuxième élément est le caractère.
  • ⍳⍴⍵donne un vecteur de 1 à ⍴⍵, ou la longueur de la chaîne d'entrée.
  • ⍵,⍨¨applique la fonction de concaténation commuée ( ,⍨) à chaque ¨élément ( ) à sa gauche ( ⍵, dans ce cas, l'entrée de l'utilisateur) et à sa droite. La commutation de la fonction de concaténation entraîne l'échange de ses arguments gauche et droit.
  • Enfin, nous joignons le résultat à l'aide de ⊂, afin de pouvoir différencier les lignes d'entrée.
• Nous alimentons initialement notre fonction avec une entrée utilisateur ( ⍞).
• Enfin, nous réduisons ( /) notre vecteur de vecteurs de paires résultant en utilisant la fonction d'intersection ( ∩), ce qui donne les paires que l'on trouve dans tous les sous-vecteurs.

Golfscript (28 caractères)

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

Il y a des problèmes de jeu de caractères lors de la transmission d'Unicode, donc pas de bonus d'un quart de point.

J, 57 51 44 40 caractères

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

J'y arrive lentement mais sûrement. C'est encore loin d'être idéal même si je pense.

J'étais convaincu que l'utilisation d'un crochet serait la réponse, mais malheureusement pas (44 caractères):

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

J'ai peut-être besoin d'une méthode complètement différente pour raccourcir.

Haskell, 64 caractères

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

Gère les lignes de longueur inégale. La prise en charge Unicode dépend des paramètres régionaux actuels.

Exemple de sortie:

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

Python 2, score 81,5 ( 116 94 86 83 82 octets moins bonus)

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 caractères

Si quelqu'un a d'autres astuces pour cela, veuillez remplir gratuitement pour commenter!

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

Résultat:

1 a
4 j
7 g

Perl, 87 caractères (−½ char bonus tie-break)

Voici une version golfée de ma propre solution à partir du thread SO :

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

Contrairement à la version SO, celle-ci utilise des index basés sur 1 pour la sortie. Il utilise la fonctionnalité Perl 5.10 say, doit donc être exécuté avec perl -M5.010(ou avec perl -E).

Comme la version SO, ces manches lignes de code de longueur variable, et ne traitent entrée Unicode arbitraire si l'entrée standard et la sortie sont en mode UTF-8. Hélas, par défaut, ils ne le sont pas, sauf si l'on spécifie le commutateur de ligne de commande non libre -CS . Ainsi, il gagne le bonus de -½ char, mais pas le -¼.

Edit: +1 caractère pour corriger un bug: ce n'est pas parce que les chaînes d'entrée ne contiennent pas de sauts de ligne qu'ils ne peuvent pas se retrouver $a(par exemple "+" & "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: (−¼ pour la manipulation de l'UTF-8)

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

non golfé, et Source.fromFile ("f")au lieu de stdinpour une meilleure testabilité:

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

Résultat:

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

Merci à Gareth pour la réduction de la taille 8 pour l'utilisation stdin.

VBA ( 307,25 284 - 0,75 bonus = 283,25)

Je sais que cela a déjà été gagné, mais voici ma photo (ne pas lire un fichier, juste une chaîne - doit avoir l'io ajouté). J'aime que j'ai pu utiliser l()récursivement. Je n'ai généralement pas besoin de récursivité ma programmation réelle. Je n'ai fait que beaucoup de tests, mais je pense que cela couvre la stipulation des points bonus unicode. Il suppose également qu'il vbCrs'agit du terminateur de ligne. Cela peut ne pas se traduire sur tous les systèmes à cause de cela.

Code:

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

Exemple d'entrée / sortie:

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

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

Q, 32

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

usage

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

K, 22

La solution ci-dessus peut être réduite à 22 en l'écrivant complètement en K plutôt qu'en passant les fonctions K à un interpréteur Q, réduisant ainsi le nombre de parenthèses requises.

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

PHP, 123 127 :(

Je ne suis pas satisfait (il y a forcément des améliorations à apporter), mais voici:

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

Preuve que ça marche.

Si quelqu'un peut penser à un moyen plus intelligent d'initialiser $ a et $ b, faites-le moi savoir. À l'origine, j'avais $a=$b=$n=''et $ b était finalement correct, mais [empty] & [anything] == [empty]$ a n'a jamais eu de contenu.

Edit: a dû corriger la gestion de la nouvelle ligne (+6) mais a supprimé la balise de fermeture (-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)

Démo: http://jsfiddle.net/Fv7kY/4/

Edit 1 : Réorganisez les boucles pour éviter les accolades. Initialisez i avec []pour combiner avec s. Déplacez l' wincrément dans l'expression.

Edit 2 : paramétrez S=Ipour capturer le dernier mot entré et enregistrez-le avec s[1]. Combinez r=1et ++c<S.length. Placez C=s[c]dans la boucle intérieure et comparez à Cau lieu des mots précédents et suivants pour raccourcir l'expression s[w][c]==s[w++][c]à juste s[w++][c]==C. Enregistré un total de 9 caractères. Défini également w=r=...parce que lorsque c'est vrai, w=1c'est avec quoi nous devons initialiser w.

Rubis (71)

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

production:

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

Lisp commun, 183 165 caractères

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

Format lisible:

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

Saisissez-le directement dans le REPL et entrez les lignes, en terminant par une ligne vide.

C, 126 caractères

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

J'ai regardé ça mais je ne peux pas le réduire. Une nouvelle approche peut être nécessaire.

(Pas de points bonus; il ne gère les lignes de tailles différentes que si la première ligne est la plus courte.)

C # avec .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 ligne, 280 caractères
• Comprend toutes les instructions nécessaires et la méthode Main.
• Le programme ne nécessite pas ligne vide à la fin, mais l'acceptera
• Les lignes vides sont ignorées
• Gère les chaînes d'entrée de n'importe quelle longueur.
• Réserve la sortie jusqu'à la fin (alors que la réponse originale fournissait une sortie incrémentielle)

Version lisible

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

Réponse originale

en utilisant 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 ligne
• 207 caractères
• Comprend toutes les instructions nécessaires et la méthode Main.
• Le programme se termine lorsqu'une ligne vide est entrée.
• Ne gère pas les chaînes d'entrée plus courtes que la première.

    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 caractères :

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

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