Mi sono imbattuto in questa domanda su SO e ho pensato che sarebbe stata una bella sfida di golf. Quindi eccolo qui:

Sfida:

Scrivi un programma che legge una sequenza di stringhe di caratteri, una per riga, e genera un elenco di tutte le posizioni in cui ogni stringa ha lo stesso carattere.

Ingresso e uscita:

L'input è costituito da una o più righe di caratteri ASCII non bianchi stampabili, ciascuno seguito da una nuova riga. Si può presumere che tutte le linee di input abbiano la stessa lunghezza. La nuova riga non deve essere considerata parte dell'input (ovvero non dovresti emetterlo come carattere corrispondente).

Input di esempio (rubato spudoratamente dalla domanda SO):

abcdefg
avcddeg
acbdeeg

Dopo aver letto l'input, il programma dovrebbe stampare le posizioni di ciascuna colonna corrispondente e i caratteri che contengono. (Il tuo programma potrebbe, ma non è necessario, interrompere la lettura di ulteriori input se può determinare in anticipo che non ci sono colonne corrispondenti.) È consentito qualsiasi formato di output ragionevole; in particolare, è possibile utilizzare l'indicizzazione basata su 0 o 1 per le posizioni.

Esempio di output per l'input sopra (usando l'indicizzazione basata su 0):

0: a
3: d
6: g

punteggio:

Questo è il golf del codice, quindi vince la risposta più breve. In caso di pareggio, i caratteri frazionari del tie-breaker possono essere assegnati per funzioni aggiuntive:

• ½ caratteri per gestire correttamente le linee di input di lunghezza diversa. (L'output non deve contenere posizioni oltre la fine della riga di input più breve.)
• ¼ caratteri per gestire correttamente l'input costituito da caratteri Unicode codificati UTF-8 arbitrari.

Per ispirazione, potresti trovare alcune soluzioni non golfate alla domanda SO (vedi sopra).

chiarimenti:

• Il semplice concatenamento di posizioni e caratteri, come in 0a3d6g, non conta come "output ragionevole". Dovresti fornire un tipo di separatore (come uno spazio) tra ogni elemento dell'output in modo che possa essere analizzato in modo univoco.

• L'input verrà fornito sul flusso di input standard ( stdin) o utilizzando qualsiasi meccanismo di input del file di testo più naturale per la lingua scelta. (Se la lingua scelta non ha un meccanismo naturale per l'input dei file, fai quello che sembra più vicino nello spirito.)

• L'input termina quando non ci sono più dati da leggere (cioè quando si verifica una condizione di fine file). Se si desidera, è possibile richiedere che l'ingresso essere terminato da una riga vuota (che poi non dovrebbe contare come parte dell'ingresso, ovviamente). Se lo fai, ti preghiamo di menzionarlo nella tua risposta in modo che altri possano fornire input corretti per il test.

• Ogni riga di input, compresa l'ultima, termina con un carattere di nuova riga. La tua risposta non deve riportare questa riga come una colonna corrispondente. (Va bene se la tua soluzione può anche gestire input in cui l'ultima riga non termina in una nuova riga, ma ciò non è necessario.)

APL, 25 caratteri

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

Ho usato Dyalog APL (versione 13) come mio interprete. Gestisce entrambi gli input di lunghezza diversa e i caratteri Unicode (UTF-8).

Esempi:

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

  1 a  4 d  7 g  

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

  4 t  5 日  6 本 

Spiegazione, un po 'da destra a sinistra:

• La parte principale di questa risposta è la funzione diretta (sostanzialmente, funzione anonima), definita tra parentesi graffe. L'argomento giusto è specificato da ⍵.
  • 0=⍴⍵:⍬è la nostra prima espressione e verifica se abbiamo ottenuto una riga vuota (ovvero, abbiamo finito). Usa una guardia (un costrutto familiare a molti programmatori funzionali) per eseguire in modo condizionale l'espressione alla destra dei due punti. In questo caso, se 0 è uguale alla forma / lunghezza ( ⍴) dell'argomento giusto, restituiamo il set vuoto ( ⍬).
  • ⋄separa le due espressioni all'interno della funzione. Se l'espressione precedente non è stata valutata (e quindi non ha restituito nulla), passiamo all'espressione successiva.
  • Chiamiamo ricorsivamente la funzione usando la funzione di auto-riferimento ( ∇). L'argomento della funzione è una riga di input dell'utente non valutato, fornita da quote-quad ( ⍞).
  • ⊂⍵,⍨¨⍳⍴⍵ crea coppie per ogni carattere nella stringa, dove il primo elemento di ogni coppia è la sua posizione nella stringa e il suo secondo elemento è il carattere.
  • ⍳⍴⍵fornisce un vettore compreso tra 1 ⍴⍵e la lunghezza della stringa di input.
  • ⍵,⍨¨applica la funzione di concatenazione commutata ( ,⍨) a ciascun ¨elemento ( ) a sinistra ( ⍵, in questo caso l'input dell'utente) e a destra. Il pendolarismo della funzione di concatenazione provoca lo scambio degli argomenti destro e sinistro.
  • Infine, alleghiamo il risultato usando ⊂, in modo da poter differenziare le righe di input.
• Inizialmente alimentiamo la nostra funzione con l'input dell'utente ( ⍞).
• Infine, riduciamo ( /) il nostro vettore risultante di vettori di coppie usando la funzione di intersezione ( ∩), producendo le coppie che si trovano in tutti i sotto-vettori.

Golfscript (28 caratteri)

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

Ci sono problemi con il set di caratteri durante il piping di Unicode, quindi nessun bonus di un quarto di punto.

J, 57 51 44 40 caratteri

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

Ci sto arrivando lentamente ma sicuramente. Questo è ancora tutt'altro che ideale, anche se penso.

Ero sicuro che usare un hook sarebbe stata la risposta, ma sfortunatamente no (44 caratteri):

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

Potrei aver bisogno di un metodo completamente diverso per accorciarmi.

Haskell, 64 caratteri

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

Gestisce linee di lunghezza diversa. Il supporto Unicode dipende dalle impostazioni internazionali correnti.

Esempio di output:

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

Python 2, punteggio 81,5 ( 116 94 86 83 82 byte meno 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 caratteri

Se qualcuno ha qualche altro trucco per questo, si prega di compilare gratuitamente per commentare!

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

Risultato:

1 a
4 d
7 g

Perl, 87 caratteri (−½ bonus tie-break)

Ecco una versione golf della mia soluzione dal thread SO :

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

A differenza della versione SO, questa utilizza indici basati su 1 per l'output. Utilizza la sayfunzione Perl 5.10 , quindi deve essere eseguito con perl -M5.010(o con perl -E).

Come la versione SO, fronteggia codice linee di lunghezza variabile, e sarebbero gestiscono input arbitrari Unicode se l'input e output standard erano in modalità UTF-8. Purtroppo, per impostazione predefinita non lo sono, a meno che non si specifichi l'opzione della riga di comando non libera -CS . Pertanto, guadagna il bonus di ½ ½, ma non quello ¼.

Modifica: +1 carattere per correggere un bug: solo perché le stringhe di input non contengono feed di riga non significa che non possano finire in $a(es "+" & "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: (−¼ per la gestione di UTF-8)

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

non golfato e Source.fromFile ("f")invece di stdinuna migliore testabilità:

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

Risultato:

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

Grazie a Gareth per la riduzione della taglia 8 per l'utilizzo stdin.

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

So che questo è già stato vinto, ma ecco il mio colpo (non leggere un file, solo una stringa - deve essere aggiunto lo io). Mi piace che devo usarel() ricorsivamente. Di solito non ho bisogno di ricorrere alla mia programmazione di vita reale. Ho fatto solo molti test, ma credo che questo copra la clausola del punto bonus unicode. Presuppone anche che vbCrsia il terminatore di linea. Questo potrebbe non tradursi in tutti i sistemi a causa di ciò.

Codice:

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

Esempio di input / output:

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 soluzione sopra può essere ridotta a 22 scrivendola completamente in K invece di passare le funzioni K a un interprete Q, riducendo il numero di parentesi richieste.

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

PHP, 123 127 :(

Non sono contento (ci saranno sicuramente miglioramenti da apportare), ma ecco qui:

<?$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 che funziona.

Se qualcuno può pensare a un modo più intelligente di inizializzare $ ae $ b, per favore fatemelo sapere. Inizialmente avevo $a=$b=$n=''$ b alla fine era corretto, ma [empty] & [anything] == [empty]$ a non ha mai avuto contenuto.

Modifica: ha dovuto correggere la gestione della nuova riga (+6) ma ha lasciato cadere il tag di chiusura (-2).

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

Modifica 1 : riorganizzare i loop per evitare le parentesi graffe. Inizializza i con []da combinare con s. Sposta l' wincremento in espressione.

Modifica 2 : ImpostaS=I di acquisire l'ultima parola inserita e salvarla con s[1]. Combina r=1e ++c<S.length. Impostalo C=s[c]in un ciclo interno e confronta con Cinvece delle parole precedenti e successive per abbreviare l'espressione s[w][c]==s[w++][c]in giusto s[w++][c]==C. Hai salvato un totale di 9 caratteri. Impostato anche w=r=...perché quando questo è vero, w=1è ciò con cui dobbiamo inizializzare w.

Rubino (71)

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

produzione:

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

Lisp comune, 183 165 caratteri

(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 leggibile:

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

Inserire questo direttamente nel REPL e inserire le righe, terminando con una riga vuota.

C, 126 caratteri

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

Lo stavo fissando ma non riesco proprio a ridurlo. Potrebbe essere necessario un nuovo approccio.

(Nessun punto bonus; gestisce solo linee di dimensioni diverse se la prima è quella più 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 riga, 280 caratteri
• Include tutte le istruzioni usando necessarie e il metodo principale.
• Il programma non richiede una riga vuota alla fine, ma lo accetterà
• Le righe vuote vengono ignorate
• Gestisce stringhe di input di qualsiasi lunghezza.
• Prenota l'output fino alla fine (mentre la risposta originale ha fornito output incrementale)

Versione leggibile

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

Risposta originale

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

• 1 riga
• 207 caratteri
• Include tutte le istruzioni usando necessarie e il metodo principale.
• Il programma termina quando viene inserita una riga vuota.
• Non gestisce le stringhe di input più brevi della prima.

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

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

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