Natknąłem się na to pytanie na SO i pomyślałem, że będzie to fajne wyzwanie golfowe. Oto on:

Wyzwanie:

Napisz program, który czyta sekwencję ciągów znaków, po jednym w wierszu, i wyświetla listę wszystkich pozycji, w których każdy ciąg ma ten sam znak.

Wejście i wyjście:

Dane wejściowe składają się z co najmniej jednego wiersza drukowalnych znaków ASCII, które nie są spacjami, a po każdym następuje nowy wiersz. Państwo może założyć, że wszystkie linie wejściowe mają taką samą długość. Nowa linia nie powinna być uważana za część danych wejściowych (tzn. Nie należy wyprowadzać jej jako pasującego znaku).

Przykładowe dane wejściowe (bezwstydnie skradzione z pytania SO):

abcdefg
avcddeg
acbdeeg

Po odczytaniu danych wejściowych program powinien wydrukować pozycje każdej pasującej kolumny i zawarte w nich znaki. (Twój program może, ale nie musi, przestać czytać dalsze dane wejściowe, jeśli może wcześnie ustalić, że nie ma pasujących kolumn). Dowolny rozsądny format wyjściowy jest dozwolony; w szczególności możesz użyć indeksowania opartego na 0 lub na podstawie 1 dla pozycji.

Przykładowe dane wyjściowe dla powyższych danych wejściowych (przy użyciu indeksowania opartego na 0):

0: a
3: d
6: g

Punktacja:

To jest golf golfowy, więc wygrywa najkrótsza odpowiedź. W przypadku remisu ułamkowe znaki rozdzielające remisy mogą zostać przyznane za dodatkowe funkcje:

• ½½ znaki do prawidłowej obsługi wierszy wejściowych o nierównej długości. (Dane wyjściowe nie powinny zawierać pozycji poza końcem najkrótszej linii wejściowej.)
• ¼ znaków do poprawnej obsługi danych wejściowych składających się z dowolnych znaków Unicode zakodowanych w UTF-8.

Aby uzyskać inspirację, możesz znaleźć nierozwiązane rozwiązania w pytaniu SO (patrz wyżej).

Wyjaśnienia:

• Po prostu łączenie pozycji i znaków, jak w 0a3d6g, nie liczy się jako „rozsądny wynik”. Powinieneś zapewnić jakiś separator (na przykład spację) między każdym elementem wyniku, aby można go było jednoznacznie przeanalizować.

• Dane wejściowe będą dostarczane w standardowym strumieniu wejściowym ( stdin) lub przy użyciu dowolnego mechanizmu wprowadzania plików tekstowych, który jest najbardziej naturalny dla wybranego języka. (Jeśli wybrany język nie ma naturalnego mechanizmu wprowadzania plików, rób wszystko, co wydaje się najbliższe duchowi.)

• Dane wejściowe kończą się, gdy nie ma już danych do odczytu (tj. Gdy wystąpi warunek końca pliku). Jeśli chcesz, to może wymagać, że wejście zostać rozwiązana przez pustą linię (które następnie nie należy liczyć jako część wkładu, oczywiście). Jeśli to zrobisz, proszę o tym wspomnieć w swojej odpowiedzi, aby inni mogli podać poprawne dane wejściowe do testów.

• Każda linia wprowadzania, w tym ostatnia, kończy się znakiem nowej linii. Twoja odpowiedź nie może zgłaszać tego nowego wiersza jako pasującej kolumny. (W porządku, jeśli twoje rozwiązanie obsługuje również dane wejściowe, w których ostatni wiersz nie kończy się na nowej linii, ale nie jest to wymagane).

APL, 25 znaków

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

Jako interpretera użyłem Dyalog APL (wersja 13). Obsługuje zarówno dane wejściowe o nierównej długości, jak i znaki Unicode (UTF-8).

Przykłady:

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

  1 a  4 d  7 g  

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

  4 t  5 日  6 本 

Objaśnienie, nieco od prawej do lewej:

• Główną częścią tej odpowiedzi jest funkcja bezpośrednia (w zasadzie funkcja anonimowa), zdefiniowana w nawiasach klamrowych. Jego właściwy argument jest określony przez ⍵.
  • 0=⍴⍵:⍬jest naszym pierwszym wyrażeniem i sprawdza, czy otrzymaliśmy pustą linię (tzn. skończymy). Wykorzystuje wartownik (znajomy konstrukt dla wielu programistów funkcjonalnych), aby warunkowo wykonać wyrażenie po prawej stronie jelita grubego. W takim przypadku, jeśli 0 jest równe kształtowi / długości ( ⍴) odpowiedniego argumentu, zwracamy pusty set ( ⍬).
  • ⋄oddziela dwa wyrażenia w ramach funkcji. Jeśli poprzednie wyrażenie nie zostało ocenione (a zatem nic nie zwróciło), przechodzimy do następnego wyrażenia.
  • Rekurencyjnie wywołujemy funkcję za pomocą funkcji samodzielnego odwoływania się ( ∇). Argumentem tej funkcji jest wiersz bez oceny danych wejściowych użytkownika, podany przez quote-quad ( ⍞).
  • ⊂⍵,⍨¨⍳⍴⍵ tworzy pary dla każdego znaku w ciągu, gdzie pierwszym elementem każdej pary jest jego pozycja w ciągu, a drugim elementem jest znak.
  • ⍳⍴⍵daje wektor od 1 do ⍴⍵lub długość ciągu wejściowego.
  • ⍵,⍨¨stosuje funkcję zamiany konkatenacji ( ,⍨) do każdego ¨elementu ( ) po jego lewej stronie ( ⍵w tym przypadku danych wejściowych użytkownika) i prawej. Dojazdy do funkcji konkatenacji powoduje zamianę jej lewego i prawego argumentu.
  • Na koniec załączamy wynik za pomocą ⊂, abyśmy mogli rozróżnić linie wprowadzania.
• Początkowo karmimy naszą funkcję danymi wejściowymi użytkownika ( ⍞).
• Na koniec redukujemy ( /) nasz wynikowy wektor wektorów par za pomocą funkcji przecięcia ( ∩), uzyskując pary, które znajdują się we wszystkich wektorach podrzędnych.

Golfscript (28 znaków)

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

Występują problemy z zestawem znaków podczas przesyłania przez Unicode, więc nie ma premii za ćwierć punktu.

J, 57 51 44 40 znaków

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

Docieram tam powoli, ale na pewno. Myślę, że wciąż jest to dalekie od ideału.

Byłem pewien, że użycie haka byłoby odpowiedzią, ale niestety nie (44 znaki):

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

Mogę potrzebować zupełnie innej metody, aby skrócić.

Haskell, 64 znaków

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

Obsługuje linie o nierównej długości. Obsługa Unicode zależy od bieżących ustawień regionalnych.

Przykładowe dane wyjściowe:

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

Python 2, wynik 81,5 ( 116 94 86 83 82 bajtów 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) Skrypty powłoki, 105 znaków

Jeśli ktoś ma do tego więcej sztuczek, prosimy o wypełnienie komentarza!

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

Wynik:

1 a
4 d
7 g

Perl, 87 znaków (½½ char premia za remis)

Oto golfowa wersja mojego własnego rozwiązania z wątku SO :

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

W przeciwieństwie do wersji SO, ten używa indeksów opartych na 1 dla danych wyjściowych. Korzysta z funkcji Perl 5.10 say, więc musi być uruchamiany z perl -M5.010(lub z perl -E).

Podobnie jak w wersji tak, to uchwyty kod linie o zmiennej długości, a będzie obsługiwać dowolny wkład Unicode jeśli standardowe wejście i wyjście było w trybie UTF-8. Niestety, domyślnie nie są, chyba że określono niewolny -CS przełącznik wiersza poleceń. W ten sposób zarabia premię ½ ½ char, ale nie ¼.

Edycja: +1 char, aby naprawić błąd: tylko dlatego, że ciągi wejściowe nie zawierają kanałów, nie oznacza, że ​​nie mogą się skończyć $a(np "+" & "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: (¼ do obsługi UTF-8)

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

bez golfa, a Source.fromFile ("f")zamiaststdin dla lepszej testowalności:

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

Wynik:

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

Dzięki Garethowi za zmniejszenie rozmiaru 8 za użycie stdin.

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

Wiem, że to już zostało wygrane, ale oto mój strzał (nie czytam pliku, tylko ciąg znaków - trzeba dodać io). Podoba mi się, że muszę używać l()rekurencyjnie. Zazwyczaj nie potrzebuję rekurencji w moim prawdziwym programowaniu. Zrobiłem tylko tyle testów, ale uważam, że obejmuje to punkt bonusowy Unicode. Zakłada również, że vbCrjest to terminator linii. Z tego powodu może to nie zostać przetłumaczone na wszystkie systemy.

Kod:

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

Przykładowe wejście / wyjście:

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

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

P, 32

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

stosowanie

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

K, 22

Powyższe rozwiązanie można zredukować do 22, pisząc je całkowicie w K, zamiast przekazywać funkcje K do interpretera Q, co zmniejsza liczbę wymaganych nawiasów.

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

PHP, 123 127 :(

Nie jestem z tego zadowolony (będą musiały zostać wprowadzone ulepszenia), ale oto:

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

Dowód to działa.

Jeśli ktoś może wymyślić bardziej sprytny sposób inicjowania $ a i $ b, daj mi znać. Początkowo miałem, $a=$b=$n=''a $ b w końcu było poprawne, ale [empty] & [anything] == [empty]więc $ a nigdy nie miałem treści.

Edycja: Musiałem naprawić obsługę nowego wiersza (+6), ale upuściłem zamykający tag (-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)

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

Edycja 1 : Zmień kolejność pętli, aby uniknąć nawiasów klamrowych. Zainicjuj i, []aby połączyć z s. Przesuń wprzyrost wyrażenia.

Edycja 2 : Ustaw S=Iprzechwytywanie ostatnio wprowadzonego słowa i zapisywanie za pomocą s[1]. Połącz r=1i ++c<S.length. Ustaw C=s[c]w wewnętrznej pętli i porównaj Cz poprzednimi i następnymi słowami, aby skrócić wyrażenie s[w][c]==s[w++][c]do just s[w++][c]==C. Zapisano w sumie 9 znaków. Także ustawione, w=r=...ponieważ kiedy to prawda, w=1to właśnie z tym musimy zainicjować w.

Rubin (71)

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

wynik:

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

Common Lisp, 183 165 znaków

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

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

Wprowadź to bezpośrednio do REPL i wprowadź linie, kończąc pustą linią.

C, 126 znaków

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

Patrzyłem na to, ale po prostu nie mogę go zmniejszyć. Konieczne może być nowe podejście.

(Brak punktów bonusowych; obsługuje linie różnej wielkości tylko wtedy, gdy pierwsza linia jest krótsza.)

C # z .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 linia, 280 znaków
• Obejmuje wszystkie niezbędne instrukcje i metodę Main.
• Program nie wymaga pustej linii na końcu, ale ją zaakceptuje
• Puste linie są ignorowane
• Obsługuje ciągi wejściowe o dowolnej długości.
• Rezerwuje dane wyjściowe do końca (podczas gdy pierwotna odpowiedź zawierała dane wyjściowe przyrostowe)

Wersja do odczytu

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

Oryginalna odpowiedź

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

• 1 linia
• 207 znaków
• Obejmuje wszystkie niezbędne instrukcje i metodę Main.
• Program kończy się po wprowadzeniu pustej linii.
• Nie obsługuje ciągów wejściowych krótszych niż pierwszy.

    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 znaków :

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

DO#

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