Khoảng cách Hamming giữa hai chuỗi có độ dài bằng nhau là số vị trí mà các ký tự tương ứng khác nhau. Nếu các chuỗi không có độ dài bằng nhau, khoảng cách Hamming không được xác định.

Thử thách

Viết chương trình hoặc hàm tìm khoảng cách Hamming lớn nhất trong số tất cả các cặp chuỗi từ danh sách các chuỗi, được đệm theo yêu cầu theo các quy tắc được mô tả bên dưới.

Các nhân vật sẽ từ bên trong a-zA-Z0-9.

Các chuỗi có thể không bằng nhau về chiều dài, do đó, đối với mỗi so sánh, chuỗi ngắn hơn phải được đệm như sau:

• quấn chuỗi từ đầu nhiều lần cần thiết để phù hợp với độ dài cần thiết
• thay đổi trường hợp của các chữ cái mỗi gói thời gian lẻ (thứ 1, thứ 3, thứ 5, v.v.)
• để những thứ bên ngoài a-zA-Zkhông thay đổi khi gói

Ví dụ: giả sử bạn cần đệm chuỗi 5 ký tự ab9Cdđể kết thúc bằng 18 ký tự. Bạn sẽ kết thúc với:

ab9CdAB9cDab9CdAB9
     ^^^^^     ^^^

với ^thêm dưới 1 và thứ 3 kết thúc tốt đẹp với điểm nhấn cho trường hợp thay đổi.

Đầu ra đầu vào

Định dạng đầu vào / đầu ra là linh hoạt. Bạn có thể giả sử đầu vào có ít nhất hai chuỗi và tất cả các chuỗi sẽ có ít nhất một ký tự.

Đầu ra là một số nguyên.

Quy tắc

Đây là mã golf . Quy tắc tiêu chuẩn áp dụng.

Các trường hợp thử nghiệm

[ "a", "b" ] => 1
[ "a", "b", "c" ] => 1
[ "a", "a", "c" ] => 1
[ "abc", "abcd" ] => 1
[ "abc12D5", "abC34d3", "ABC14dabc23DAbC89d"] => 17  
[ "a", "Aaa", "AaaA", "aAaAa", "aaaaaaaaaaaaaa", "AAaAA", "aAa" ] => 8
["AacaAc", "Aab"] => 2

Thực hiện tham khảo

Tôi đã thử nghiệm các ví dụ với mã R (hoàn toàn không được mã hóa) mà bạn có thể thử ở đây để so sánh với bất kỳ ví dụ nào khác mà bạn có thể thử với mã của mình.

Thạch , 20 byte

Không thực sự hài lòng với nó. Có thể chơi được, thậm chí đến ~ 15 byte.

LÞŒcµṁ/sḢL$ŒsÐeFn)§Ṁ

Hãy thử trực tuyến!

hoặc Kiểm tra một bộ thử nghiệm!

Giải trình

Lṁc hèṁ / sḢL $ sĐeFn) §Ṁ Chương trình đầy đủ hoặc liên kết đơn âm. N = đầu vào. | Ví dụ: ["abc12D5", "abC34d3", "ABC14dabc23DAbC89d"]
LÞ Sắp xếp N theo chiều dài. | [['A', 'b', 'c', '1', '2', 'D', '5'], ['a', 'b', 'C', '3', '4 ',' D ',' 3 '], [' A ',' B ',' C ',' 1 ',' 4 ',' d ',' a ',' b ',' c ',' 2 ',' 3 ',' D ',' A ',' b ',' C ',' 8 ',' 9 ',' d ']] (trong Jelly, chuỗi là danh sách các ký tự)
  Œc Các cặp không được sắp xếp: [x, y] cho tất cả các x, y riêng biệt trong N. | [[['A', 'b', 'c', '1', '2', 'D', '5'], ['a', 'b', 'C', '3', ' 4 ',' d ',' 3 ']], [[' a ',' b ',' c ',' 1 ',' 2 ',' D ',' 5 '], [' A ',' B ',' C ',' 1 ',' 4 ',' d ',' a ',' b ',' c ',' 2 ',' 3 ',' D ',' A ',' b ' , 'C', '8', '9', 'd']], [['a', 'b', 'C', '3', '4', 'd', '3'], ['A', 'B', 'C', '1', '4', 'd', 'a', 'b', 'c', '2', '3', 'D',
                        Ở đây, bởi sự khác biệt, tôi có nghĩa là ở các vị trí khác nhau. |
    Bản đồ) với một liên kết đơn âm. |
     / Khuôn x như y. Đó là, chu kỳ x cho đến khi nó đạt đến độ dài y. | [['A', 'b', 'c', '1', '2', 'D', '5'], ['a', 'b', 'c', '1', '2 ',' D ',' 5 ',' a ',' b ',' c ',' 1 ',' 2 ',' D ',' 5 ',' a ',' b ',' c ', '1'], ['a', 'b', 'C', '3', '4', 'd', '3', 'a', 'b', 'C', '3', '4', 'd', '3', 'a', 'b', 'C', '3']]
       sḢL $ Chia thành các đoạn có độ dài x. | [[['A', 'b', 'c', '1', '2', 'D', '5']], [['a', 'b', 'c', '1' , '2', 'D', '5'], ['a', 'b', 'c', '1', '2', 'D', '5'], ['a', ' b ',' c ',' 1 ']], [[' a ',' b ',' C ',' 3 ',' 4 ',' d ',' 3 '], [' a ',' b ',' C ',' 3 ',' 4 ',' d ',' 3 '], [' a ',' b ',' C ',' 3 ']]]
           Œsđe Hoán đổi trường hợp các khối được lập chỉ mục chẵn (1 chỉ mục). | [[['A', 'b', 'c', '1', '2', 'D', '5']], [['a', 'b', 'c', '1' , '2', 'D', '5'], ['A', 'B', 'C', '1', '2', 'd', '5'], ['a', ' b ',' c ',' 1 ']], [[' a ',' b ',' C ',' 3 ',' 4 ',' d ',' 3 '], [' A ',' B ',' c ',' 3 ',' 4 ',' D ',' 3 '], [' a ',' b ',' C ',' 3 ']]]
               Làm phẳng. | [['A', 'b', 'c', '1', '2', 'D', '5'], ['a', 'b', 'c', '1', '2 ',' D ',' 5 ',' A ',' B ',' C ',' 1 ',' 2 ',' d ',' 5 ',' a ',' b ',' c ', '1'], ['a', 'b', 'C', '3', '4', 'd', '3', 'A', 'B', 'c', '3', '4', 'D', '3', 'a', 'b', 'C', '3']]
                Bất đẳng thức vectơ với y. | [[[0, 0, 1, 1, 1, 1, 1]], [[1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 , 1, 1, 1]], [[1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1]]]
                  § Sau khi kết thúc bản đồ, tính tổng từng mảng bool (0 hoặc 1). | [[5], [17], [14]]
                   Tối đa. | 17

Python 2 , 86 byte

lambda a:max(sum(x!=y for x,y in zip((s+s.swapcase())*len(t),t))for s in a for t in a)

Hãy thử trực tuyến!

Với hai chuỗi, s,t, zip((s+s.swapcase())*len(t),t))sẽ là một danh sách các hàng có độ dài len(t)từ năm zipsẽ cắt cụt đến iterable ngắn nhất. Nếu len(s)<len(t), thì "miếng đệm" này svới trường hợp hoán đổi mong muốn và chúng tôi tính toán các sumký tự khác nhau.

Nếu len(t)<=len(s), thì kết quả sumsẽ nhỏ hơn hoặc bằng sumnếu chúng ta đang đánh giá t,s; Vì vậy, nó không có ảnh hưởng đến kết quả maxtrong trường hợp đó.

JavaScript (Node.js) , 111 byte

a=>a.map(m=S=>a.map(s=>B(S).map((c,k)=>m=(c^(c=B(s)[k%(l=s.length)])^(k/l&c>9)<<5&&++x)<m?m:x,x=0)),B=Buffer)|m

Hãy thử trực tuyến!

Thạch , 19 byte

WṁŒsÐeF=ċ0
LÞŒcç/€Ṁ

Hãy thử trực tuyến!

LÞŒcç/€Ṁ
LÞ         Sort by length
  Œc       unordered pairs
      €    to each of the pairs
    ç/     find the hamming distance with molding and swapping case (helper link)
       Ṁ   maximum

WṁŒsÐeF=ċ0
W            wrap the shorter string
 ṁ           repeat this string once for each character in the second string
    Ðe       for every other repeated string
  Œs         swap case
      F      flatten
       =     characterwise equality check between the two strings. If the first
             string is longer, the leftover characters are appended to the result.
             e.g. 'abABab' and 'xbA' give [0,1,1,'B','a','b']
        ċ0   count the number of 0s, giving the Hamming distance.

Ruby , 89 82 byte

Tạo sản phẩm chéo của danh sách đầu vào so với chính nó trước khi tính khoảng cách Hamming của mỗi cặp, sử dụng phương pháp sao chép tương tự như câu trả lời của Chas Brown . Mặc dù vậy, Ruby không thể nén các chuỗi hoặc thêm booleans mà không cần thêm chi phí, do đó, điều cần thiết là phải lặp qua các chuỗi theo cách thủ công.

-7 byte từ GB.

->a{a.product(a).map{|s,t|(0...w=t.size).count{|i|(s+s.swapcase)[i%w]!=t[i]}}.max}

Hãy thử trực tuyến!

Java 10 ,748 740 667 666 616 byte

Đây phải là sân golf dày đặc nhất và không thể đọc được, nhưng là sân golf dài nhất tôi từng nghĩ ra.

Phương thức gọi h(String[])với một mảng rõ ràng (không có var args): eg,

h(new String[] {"a", "b", "c"});

trả lại 1.

char e(boolean w,char c){return(char)(w&(64<c&c<91|96<c&c<123)?c^32:c);}String p(String s,int l){var p="";int m=s.length(),n=l/m,r=l%m,i=0,j=0;var w=1<0;for(;i<n;++i,w=!w)for(char c:s.toCharArray())p+=e(w,c);for(;j<r;)p+=e(w,s.charAt(j++));return p;}int d(String s,String t){int l=s.length(),n=0,i=0;for(;i<l;)if(s.charAt(i)!=t.charAt(i++))++n;return n;}int h(String s,String t){int l=s.length(),m=t.length();return l>m?d(s,p(t,l)):l<m?d(p(s,m),t):d(s,t);}int h(String[]s){int l=s.length,i=0,j;int[]n=new int[l*l];for(;i<l;++i)for(j=i;++j<l;)n[i*l+j]=h(s[i],s[j]);return java.util.Arrays.stream(n).max().getAsInt();}

Bạn có thể dùng thử trực tuyến !

Ungolfed và bình luận:

// Encode the character (swap case)
char e(boolean w, char c) {
    return (char) (w & (64 < c & c < 91 | 96 < c & c < 123) ? c ^ 32 : c);
}

// Pad the string to desired length
String p(String s, int l) {
    var p = "";
    int m = s.length(), n = l / m, r = l % m, i = 0, j = 0;
    var w = 1 < 0;
    for (; i < n; ++i, w = !w)
        for (char c : s.toCharArray())
            p += e(w, c);
    for (; j < r;)
        p += e(w, s.charAt(j++));
    return p;
}

// Calculate the actual hamming distance between two same-length strings
int d(String s, String t) {
    int l = s.length(), n = 0, i = 0;
    for (; i < l;)
        if (s.charAt(i) != t.charAt(i++))
            ++n;
    return n;
}
// Pad the strings as needed and return their hamming distance
int h(String s, String t) {
    int l = s.length(), m = t.length();
    return l > m ? d(s, p(t, l)) : l < m ? d(p(s, m), t) : d(s, t);
}

    // Dispatch the strings and gather their hamming distances, return the max
int h(String[] s) {
    int l = s.length, i = 0, j;
    int[] n = new int[l * l];
    for (; i < l; ++i)
        for (j = i; ++j < l;)
            n[i * l + j] = h(s[i], s[j]);
    return java.util.Arrays.stream(n).max().getAsInt();
}

Tôi biết một giải pháp tốt hơn có thể đạt được, đặc biệt là đối với phần ghép chuỗi.

EDIT : cạo 8 byte bằng cách thay đổi kích thước của mảng int hammingDistance()thành bình phương của số chuỗi được đưa ra. Nó cũng sửa lỗi ArrayIndexOutOfBoundsném trong một trong các trường hợp thử nghiệm.

EDIT 2 : Đã lưu 33 byte nhờ nhận xét của Kevin Cruijssen : đã xóa khai báo lớp, tên được rút ngắn thành 1 char, các toán tử thay đổi, v.v.

EDIT 3 : Lưu 1 byte và đạt điểm số được Satan chấp thuận bằng cách thay đổi phương thức với var-arg thành mảng.

EDIT 4 : Lưu lại 50 byte nữa nhờ Kevin Cruijssen , một lần nữa: cập nhật phiên bản Java từ 8 lên 10 để sử dụng vartừ khóa, StringBuilderví dụ đã xóa , v.v.

05AB1E , 33 29 byte

Ćü)€é©εćDš«s`g∍}®€¤‚ø€ζ€€Ë_Oà

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Rất có thể có thể giảm một nửa số đếm byte, nhưng nó hoạt động ..

Giải trình:

Ć           # Enclose the input-list (adding the first item to the end of the list)
            #  i.e. ['ABC1','abcD','abCd32e'] → ['ABC1','abcD','abCd32e','ABC1']
 ü)         # Pair-vectorize each of them
            #  i.e. ['ABC1','abcD','abCd32e','ABC1']
            #   → [['ABC1','abcD'],['abcD','abCd32e'],['abCd32e','ABC1']]
   ێ       # Sort each pair by length
            #  i.e. [['ABC1','abcD'],['abcD','abCd32e'],['abCd32e','ABC1']]
            #   → [['ABC1','abcD'],['abcD','abCd32e'],['ABC1','abCd32e']]
     ©      # Store this list in the register to re-use later on
ε        }  # Map each inner list in this list to:
 ć          # Head extracted
            #  i.e. ['abcD','abCd32e'] → 'abcD' and ['abCd32e']
  Dš        # Duplicate it, and swap the capitalization of the copy
            #  i.e. 'abcD' → 'ABCd'
    «       # Then merge it together
            #  i.e. 'abcD' and 'ABCd' → 'abcDABCd'
     s`     # Swap so the tail-list is at the top of the stack, and get it's single item
            #  i.e. ['abCd32e'] → 'abCd32e'
       g    # Get the length of that
            #  i.e. 'abCd32e' → 7
        ∍   # Extend/shorten the string to that length
            #  i.e. 'abcDABCd' and 7 → 'abcDABC'
®           # Get the saved list from the register again
 €¤         # Get the tail from each
            #  i.e. [['ABC1','abcD'],['abcD','abCd32e'],['abCd32e','ABC1']]
            #   → ['abcD','abCd32e','abCd32e']
   ‚        # Pair it with the other list
            #  i.e. ['ABC1','abcDABC','ABC1abc'] and ['abcD','abCd32e','abCd32e']
            #   → [['ABC1','abcDABC','ABC1abc'],['abcD','abCd32e','abCd32e']]
    ø       # Zip it, swapping rows / columns
            #  i.e. [['ABC1','abcDABC','ABC1abc'],['abcD','abCd32e','abCd32e']]
            #   → [['ABC1','abcD'],['abcDABC','abCd32e'],['ABC1abc','abCd32e']]
     €ζ     # And then zip each pair again
            #  i.e. [['ABC1','abcD'],['abcDABC','abCd32e'],['ABC1abc','abCd32e']]
            #   → [['Aa','Bb','Cc','1D'],['aa','bb','cC','Dd','A3','B2','Ce'],['Aa','Bb','CC','1d','a3','b2','ce']]
€           # Then for each inner list
 €          #  And for each inner string
  Ë         #   Check if all characters are the same
            #    i.e. 'aa' → 1
            #    i.e. 'cC' → 0
   _        # And inverse the booleans
            #  i.e. [['Aa','Bb','Cc','1D'],['aa','bb','cC','Dd','A3','B2','Ce'],['Aa','Bb','CC','1d','a3','b2','ce']]
            #   → [[1,1,1,1],[0,0,1,1,1,1,1],[1,1,0,1,1,1,1]]
O           # Then sum each inner list
            #  i.e. [[1,1,1,1],[0,0,1,1,1,1,1],[1,1,0,1,1,1,1]] → [4,5,6]
 à          # And take the max as result
            #  i.e. [4,5,6] → 6

Java 11, 387 byte

a->{int l=a.length,i=l,t,j=0,C[]=new int[l];var p=new String[l][2];for(;i-->0;p[i][0]=a[t>0?i:j],p[i][1]=a[t>0?j:i])t=a[i].length()<a[j=-~i%l].length()?1:0;i=0;for(var P:p){var s="";for(var x:P[0].getBytes())s+=(char)(x>64&x<91|x>96&x<123?x^32:x);for(P[0]=repeat(P[0]+s,t=P[1].length()).substring(0,t);t-->0;)if(P[0].charAt(t)!=P[1].charAt(t))C[i]++;i++;}for(int c:C)j=c>j?c:j;return j;}

Hãy thử trực tuyến. (LƯU Ý: Vì Java 11 chưa có trên TIO, nên String.repeat(int)đã được mô phỏng như repeat(String,int)cho cùng một số byte.)

Giải trình:

a->{                      // Method with String-array parameter and integer return-type
  int l=a.length,         //  Length of the input-array
      i=l,                //  Index-integer, starting at the length
      t,j=0,              //  Temp-integers
      C[]=new int[l];     //  Count-array the same size as the input
  var p=new String[l][2]; //  String-pairs array the same size as the input
  for(;i-->0              //  Loop `i` in the range [`l`, 0)
      ;                   //    After every iteration:
       p[i][0]=           //     Set the first String of the pair at index `i` to:
               a[t>0?i:j],//      The smallest of the `i`'th or `j`'th Strings of the input-array
       p[i][1]=           //     And set the second String of the pair at index `i` to:
               a[t>0?j:i])//      The largest of the `i`'th or `j`'th Strings of the input-array
    t=a[i].length()<      //    If the length of the `i`'th item is smaller than
      a[j=-~i%l].length()?//    the length of the `i+1`'th item
                          //    (and set `j` to this `i+1` with wrap-around to 0 for the last item
       1                  //     Set `t` to 1 as flag
      :                   //    Else:
       0;                 //     Set `t` to 0 as flag
                          //  We've now created the String pairs, where each pair is sorted by length
  i=0;                    //  Reset `i` to 0
  for(var P:p){           //  Loop over the pairs
    var s="";             //   Temp-String starting empty
    for(var x:P[0].getBytes())
                          //   Loop over the characters of the first String of the pair
      s+=                 //    Append the temp-String with:
         (char)(x>64&x<91|x>96&x<123?
                         //      If the current character is a letter:
           x^32          //       Swap it's case before appending it to `s`
         :               //      Else (not a letter):
          x);            //       Append it to `s` as is
    for(P[0]=            //    Now replace the first String with:
        repeat(P[0]+s,   //     The first String appended with the case-swapped first String
               t=P[1].length())
                         //     Repeated `t` amount of times,
                         //     where `t` is the length of the second String of the pair
        .substring(0,t); //     And then shorten it to length `t`
        t-->0;)          //    Inner loop over the character of the now same-length Pairs
      if(P[0].charAt(t)!=P[1].charAt(t))
                         //     If the characters at the same indices in the pair are not equal
        C[i]++;          //      Increase the counter for this pair by 1
    i++;}                //    After every iteration of the outer loop,
                         //    increase `i` by 1 for the next iteration
  for(int c:C)           //  Now loop over the calculated counts
    j=c>j?c:j;           //   And set `j` to the maximum
  return j;}             //  And finally return this maximum `j` as result

R , 173 byte

function(x,U=utf8ToInt,N=nchar)max(combn(x,2,function(z,v=z[order(N(z))])sum(U(substr(Reduce(paste0,rep(c(v[1],chartr('A-Za-z','a-zA-Z',v[1])),n<-N(v[2]))),1,n))!=U(v[2]))))

Hãy thử trực tuyến!

@ngm: Tôi đã cố gắng hết sức để chơi mã của bạn ( dĩ nhiên là với các tùy chỉnh nặng nề của tôi) nhưng, như bạn cũng biết, R không phải là người chơi golf trong việc điều khiển dây: P