Ich bin auf SO auf diese Frage gestoßen und dachte, es wäre eine schöne Golfherausforderung. Hier ist es also:

Herausforderung:

Schreiben Sie ein Programm, das eine Folge von Zeichenfolgen (eine pro Zeile) liest und eine Liste aller Positionen ausgibt, an denen jede Zeichenfolge dasselbe Zeichen enthält.

Ein- und Ausgabe:

Die Eingabe besteht aus einer oder mehreren Zeilen druckbarer Nicht-Leerzeichen-ASCII-Zeichen, denen jeweils eine neue Zeile folgt. Sie können davon ausgehen, dass alle Eingabezeilen gleich lang sind. Die neue Zeile ist nicht als Teil der Eingabe zu betrachten (dh Sie sollten sie nicht als übereinstimmendes Zeichen ausgeben).

Beispiel-Eingabe (schamlos aus der SO-Frage gestohlen):

abcdefg
avcddeg
acbdeeg

Nach dem Lesen der Eingabe sollte Ihr Programm die Positionen jeder übereinstimmenden Spalte und die darin enthaltenen Zeichen drucken. (Ihr Programm hört möglicherweise auf, weitere Eingaben zu lesen, muss dies aber nicht, wenn es frühzeitig feststellen kann, dass keine übereinstimmenden Spalten vorhanden sind.) Jedes sinnvolle Ausgabeformat ist zulässig. Insbesondere können Sie entweder 0-basierte oder 1-basierte Indizierung für die Positionen verwenden.

Beispielausgabe für die obige Eingabe (mit 0-basierter Indizierung):

0: a
3: d
6: g

Wertung:

Dies ist Codegolf, also gewinnt die kürzeste Antwort. Im Falle eines Gleichstands können Bruchstücke von Trennzeichen für zusätzliche Merkmale vergeben werden:

• −½ Zeichen für den korrekten Umgang mit Eingabezeilen ungleicher Länge. (Die Ausgabe sollte keine Positionen nach dem Ende der kürzesten Eingabezeile enthalten.)
• −¼ Zeichen für die korrekte Verarbeitung von Eingaben, die aus beliebigen UTF-8-codierten Unicode-Zeichen bestehen.

Zur Inspiration finden Sie bei der SO-Frage (siehe oben) möglicherweise einige ungolfed Lösungen.

Klarstellungen:

• Das einfache Verketten der Positionen und Zeichen wie in 0a3d6gzählt nicht als "sinnvolle Ausgabe". Sie sollten eine Art Trennzeichen (z. B. ein Leerzeichen) zwischen den einzelnen Elementen der Ausgabe angeben, damit sie eindeutig analysiert werden können.

• Die Eingabe erfolgt über den Standardeingabestream ( stdin) oder mithilfe des für Ihre Sprache am besten geeigneten Eingabemechanismus für Textdateien. (Wenn Ihre gewählte Sprache nicht haben einen natürlichen Mechanismus für Dateieingabe, tun , was am nächsten Geist erscheint.)

• Die Eingabe endet, wenn keine Daten mehr gelesen werden müssen (dh wenn eine Dateiende-Bedingung eintritt). Wenn Sie möchten, Sie können verlangen , dass der Eingang durch eine Leerzeile beendet werden (die Sie dann nicht als Teil des Eingangs zählen sollten, natürlich). Wenn Sie dies tun, erwähnen Sie dies bitte in Ihrer Antwort, damit andere die richtigen Eingaben zum Testen machen können.

• Jede Eingabezeile, einschließlich der letzten, endet mit einem Zeilenumbruch. Ihre Antwort darf diese neue Zeile nicht als übereinstimmende Spalte enthalten. (Es ist in Ordnung, wenn Ihre Lösung auch Eingaben verarbeiten kann, bei denen die letzte Zeile nicht in einer neuen Zeile endet, dies jedoch nicht erforderlich ist.)

APL, 25 Zeichen

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

Ich habe Dyalog APL (Version 13) als Dolmetscher verwendet. Es werden sowohl Eingaben mit ungleicher Länge als auch Unicode-Zeichen (UTF-8) verarbeitet.

Beispiele:

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

  1 a  4 d  7 g  

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

  4 t  5 日  6 本 

Erklärung, etwas von rechts nach links:

• Der Hauptteil dieser Antwort ist die direkte Funktion (im Grunde anonyme Funktion), die in geschweiften Klammern definiert ist. Sein rechtes Argument wird durch angegeben ⍵.
  • 0=⍴⍵:⍬ist unser erster Ausdruck und überprüft, ob wir eine leere Zeile haben (dh wir sind fertig). Es verwendet einen Guard (ein bekanntes Konstrukt für viele funktionale Programmierer), um den Ausdruck rechts vom Doppelpunkt bedingt auszuführen. In diesem Fall geben ⍴wir die leere Menge ( ⍬) zurück , wenn 0 gleich der Form / Länge ( ) des rechten Arguments ist .
  • ⋄trennt die beiden Ausdrücke innerhalb der Funktion. Wenn der vorherige Ausdruck nicht ausgewertet wurde (und daher nichts zurückgibt), fahren wir mit dem nächsten Ausdruck fort.
  • Wir rufen die Funktion rekursiv mit der Selbstreferenzfunktion ( ∇) auf. Das Argument für die Funktion ist eine Zeile nicht ausgewerteter Benutzereingaben, die durch quote-quad ( ⍞) angegeben wird.
  • ⊂⍵,⍨¨⍳⍴⍵ Erstellt Paare für jedes Zeichen in der Zeichenfolge, wobei das erste Element jedes Paars die Position in der Zeichenfolge und das zweite Element das Zeichen ist.
  • ⍳⍴⍵Gibt einen Vektor von 1 bis ⍴⍵oder die Länge der Eingabezeichenfolge an.
  • ⍵,⍨¨Wendet die Funktion ( ,⍨) für die kommutierte Verkettung auf jedes ( ¨) Element links ( ⍵in diesem Fall auf die Benutzereingabe) und rechts an. Durch das Pendeln der Verkettungsfunktion werden die linken und rechten Argumente ausgetauscht.
  • Schließlich schließen wir das Ergebnis mit ein ⊂, damit wir zwischen Eingabezeilen unterscheiden können.
• Wir füttern unsere Funktion zunächst mit Benutzereingaben ( ⍞).
• Schließlich reduzieren ( /) wir unseren resultierenden Vektor von Vektoren von Paaren unter Verwendung der Schnittfunktion ( ∩), was die Paare ergibt, die in allen Untervektoren gefunden werden.

Golfscript (28 Zeichen)

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

Beim Weiterleiten von Unicode treten Zeichensatzprobleme auf, daher kein Viertelpunktebonus.

J, 57 51 44 40 Zeichen

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

Ich komme langsam aber sicher dorthin. Das ist noch lange nicht ideal, obwohl ich denke.

Ich war mir sicher, dass die Verwendung eines Hakens die Antwort sein würde, aber leider nicht (44 Zeichen):

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

Möglicherweise brauche ich eine ganz andere Methode, um kürzer zu werden.

Haskell, 64 Zeichen

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

Behandelt Zeilen ungleicher Länge. Die Unicode-Unterstützung hängt von den aktuellen Ländereinstellungen ab.

Beispielausgabe:

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

Python 2, Punktzahl 81,5 ( 116 94 86 83 82 Bytes minus 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 Zeichen

Wenn jemand noch ein paar Tricks dazu hat, fülle sie bitte aus, um einen Kommentar abzugeben!

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

Ergebnis:

1 a
4 d
7 g

Perl, 87 Zeichen (-½ Char Tie-Break-Bonus)

Hier ist eine Golfversion meiner eigenen Lösung aus dem SO-Thread :

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

Im Gegensatz zur SO-Version verwendet diese 1-basierte Indizes für die Ausgabe. Es verwendet die Perl 5.10- sayFunktion und muss daher mit perl -M5.010(oder mit perl -E) ausgeführt werden.

Wie die SO - Version dieser Code Griffe mit variabler Länge Linien und würden beliebige Unicode - Eingabe handhaben, wenn die Standardeingabe und -ausgabe im Modus UTF-8 waren. Leider ist dies nicht der Fall, es sei denn, man gibt den unfreien -CS Befehlszeilenschalter an. Somit erhält es den Bonus von -½ Zeichen, aber nicht den von -¼.

Bearbeiten: +1 Zeichen, um einen Fehler zu beheben: Nur weil die Eingabezeichenfolgen keine Zeilenvorschübe enthalten, heißt das nicht, dass sie nicht in $a(z "+" & "J" eq "\n". B. ) enden können .

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: (−¼ für den Umgang mit UTF-8)

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

ungolfed und Source.fromFile ("f")statt stdinzur besseren Testbarkeit:

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

Ergebnis:

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

Vielen Dank an Gareth für die Reduzierung der Größe 8 für die Verwendung stdin.

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

Ich weiß, dass dies bereits gewonnen wurde, aber hier ist mein Schuss (keine Datei lesen, nur eine Zeichenfolge - muss das io hinzugefügt werden). Ich mag es, dass ich l()rekursiv verwenden muss. Normalerweise brauche ich meine reale Programmierung nicht zu rekursivieren. Ich habe nur so viel getestet, aber ich glaube, dass dies die Unicode-Bonuspunkt-Bedingung abdeckt. Es wird auch davon ausgegangen, dass vbCres sich um den Leitungsabschluss handelt. Dies kann daher möglicherweise nicht auf alle Systeme übertragen werden.

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

Beispiel Ein- / Ausgabe:

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

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

Q, 32

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

Verwendung

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

K, 22

Die obige Lösung kann auf 22 reduziert werden, indem sie vollständig in K geschrieben wird, anstatt K-Funktionen an einen Q-Interpreter zu übergeben, wodurch die Anzahl der erforderlichen Klammern verringert wird.

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

PHP, 123 127 :(

Ich bin damit nicht zufrieden (es muss Verbesserungen geben), aber hier ist:

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

Beweis, dass es funktioniert.

Wenn sich jemand eine geschicktere Methode zum Initialisieren von $ a und $ b vorstellen kann, lassen Sie es mich bitte wissen. Ursprünglich hatte ich $a=$b=$n=''und $ b war schließlich richtig, aber [empty] & [anything] == [empty]so hatte $ a nie Inhalt.

Bearbeiten: Das Zeilenumbruch-Handling (+6) musste behoben werden, das schließende Tag (-2) wurde jedoch entfernt.

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)

Demo: http://jsfiddle.net/Fv7kY/4/

Edit 1 : Arrangiere Loops neu, um Klammern zu vermeiden. Initialisiere i mit [], um es mit zu kombinieren s. Bewegen Sie wSchritt in Ausdruck.

Bearbeiten 2 : Legt fest S=I, dass das zuletzt eingegebene Wort erfasst und mit gespeichert wird s[1]. Kombinieren r=1und ++c<S.length. Setze C=s[c]in die innere Schleife und vergleiche mit Canstatt mit den vorherigen und nächsten Wörtern, um den Ausdruck s[w][c]==s[w++][c]auf nur zu verkürzen s[w++][c]==C. Insgesamt 9 Zeichen gespeichert. Auch gesetzt, w=r=...weil wenn das wahr w=1ist, mit was wir initialisieren müssen w.

Rubin (71)

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

Ausgabe:

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

Common Lisp, 183 165 Zeichen

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

Lesbares Format:

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

Geben Sie dies direkt in die REPL ein und geben Sie Zeilen ein, die mit einer leeren Zeile enden.

C 126 Zeichen

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

Ich habe darauf gestarrt, aber ich kann es einfach nicht kleiner machen. Möglicherweise ist ein neuer Ansatz erforderlich.

(Keine Bonuspunkte; es werden nur Zeilen mit unterschiedlicher Größe verarbeitet, wenn die erste Zeile kürzer ist.)

C # mit .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 Zeile, 280 Zeichen
• Beinhaltet alle erforderlichen using-Anweisungen und die Main-Methode.
• Das Programm benötigt am Ende keine Leerzeile, akzeptiert diese aber
• Leerzeilen werden ignoriert
• Verarbeitet Eingabezeichenfolgen beliebiger Länge.
• Reserviert die Ausgabe bis zum Ende (während die ursprüngliche Antwort eine inkrementelle Ausgabe lieferte)

Lesbare Version

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

Ursprüngliche Antwort

using c = System.Console; class P {statische Lücke Main () {char [] a; var b = c.ReadLine (); a = b.ToCharArray (); while (b! = "") {for (int i = 0; i

• 1 Zeile
• 207 Zeichen
• Beinhaltet alle erforderlichen using-Anweisungen und die Main-Methode.
• Das Programm endet, wenn eine Leerzeile eingegeben wird.
• Behandelt keine Eingabezeichenfolgen, die kürzer als die erste sind.

    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 Zeichen :

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

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