প্যাডযুক্ত স্ট্রিংগুলির তালিকার মধ্যে সর্বাধিক হামিং দূরত্ব

18

সমান দৈর্ঘ্যের দুটি স্ট্রিংয়ের মধ্যে হামিং দূরত্ব হ'ল অবস্থানের সংখ্যা যা সম্পর্কিত অক্ষরগুলি পৃথক। স্ট্রিংগুলি সমান দৈর্ঘ্যের না হলে হামিং দূরত্ব নির্ধারণ করা হয় না।

চ্যালেঞ্জ

নীচে বর্ণিত বিধি অনুসারে প্রয়োজনীয় প্যাডযুক্ত স্ট্রিংয়ের তালিকা থেকে সমস্ত জোড় স্ট্রিংয়ের মধ্যে সবচেয়ে বড় হামিং দূরত্ব খুঁজে পাওয়া একটি প্রোগ্রাম বা ফাংশন লিখুন।

চরিত্রগুলি ভিতরে থেকে হবে a-zA-Z0-9।

স্ট্রিংগুলি দৈর্ঘ্যে সমান নাও হতে পারে, তাই প্রতিটি তুলনার জন্য সংক্ষিপ্ত স্ট্রিংটি নিম্নরূপে প্যাড করতে হবে:

  • প্রয়োজনীয় দৈর্ঘ্যের সাথে মেলাতে স্ট্রিংটি শুরু থেকে যতবার প্রয়োজন ততবার মুছে ফেলুন
  • প্রতিটি বিজোড় সময় মোড়ানোর চিঠির কেসগুলি পরিবর্তন করুন (1 ম, তৃতীয়, 5 তম, ইত্যাদি)
  • a-zA-Zমোড়ক করার সময় অপরিবর্তিত জিনিসগুলি বাইরে রাখুন

উদাহরণস্বরূপ, আসুন আমরা আপনাকে 5 টি অক্ষরের স্ট্রিং প্যাড ab9Cdকরতে হবে যাতে এটি 18 টি অক্ষরের সাথে শেষ হয়। আপনার সাথে শেষ হবে:

ab9CdAB9cDab9CdAB9
     ^^^^^     ^^^

সঙ্গে ^কেস পরিবর্তন হাইলাইট 1 ম এবং 3rd গোপন নীচে এখনো যোগ করেনি।

ইনপুট আউটপুট

ইনপুট / আউটপুট বিন্যাস নমনীয়। আপনি ধরে নিতে পারেন ইনপুটটিতে কমপক্ষে দুটি স্ট্রিং রয়েছে এবং সমস্ত স্ট্রিংয়ের কমপক্ষে একটি অক্ষর থাকবে।

আউটপুট একটি পূর্ণসংখ্যা হয়।

বিধি

এটি কোড-গল্ফ । স্ট্যান্ডার্ড বিধি প্রয়োগ।

পরীক্ষার মামলা

[ "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

রেফারেন্স বাস্তবায়ন

আমি (সম্পূর্ণ অবহেলিত) আর কোডের সাথে উদাহরণগুলি পরীক্ষা করেছি যা আপনি আপনার কোড দিয়ে চেষ্টা করতে পারেন এমন অন্য কোনও উদাহরণের তুলনা করতে এখানে চেষ্টা করতে পারেন ।

code-golf  string 
— NGM
সূত্র
1
প্রতিটি বিজোড় সময় মোড়ানোর জন্য চিঠিগুলির কেসগুলি পরিবর্তন করুন - ওহে ছেলে, এই প্রয়োজনীয়তাটি আমার সমাধানের জন্য ব্যথা হতে চলেছে ... আমি চ্যালেঞ্জটি পছন্দ করি, তবে +1
— মিঃ এক্সকোডার
প্রস্তাবিত পরীক্ষা মামলা: ["AacaAc", "Aab"] => 2। আমার জেলির উত্তরটির জন্য একটি উদ্দেশ্যপূর্ণ গল্ফ সেই ক্ষেত্রে ব্যর্থ হত, তবে অন্য সমস্তগুলি পাস করত।
— মিস্টার এক্সকোডার 21
@ngm দুর্দান্ত চ্যালেঞ্জ! +1
— ডন হাজার হাজার

উত্তর:

7

জেলি , 20 বাইট

এটি দিয়ে সত্যিই খুশি নয়। গল্ফযোগ্য, এমনকি সম্ভবত 15 ডলার বাইট করা উচিত।

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

এটি অনলাইন চেষ্টা করুন!

বা একটি পরীক্ষা স্যুট পরীক্ষা করে দেখুন!

ব্যাখ্যা

LÞŒcµṁ / sḢL Œ ÐsÐeFn) §Ṁ সম্পূর্ণ প্রোগ্রাম বা monadic লিঙ্ক। এন = ইনপুট। | উদাহরণ: ["abc12D5", "abC34d3", "ABC14dabc23DAbC89d"]
দৈর্ঘ্য অনুসারে এন বাছাই করুন। | [['a', 'বি', 'সি', '1', '2', 'ডি', '5'], ['এ', 'বি', 'সি', '3', '4 ',' ডি ',' 3 '], [' এ ',' বি ',' সি ',' ১ ',' ৪ ',' ডি ',' এ ',' বি ',' সি ',' ২ ',' 3 ',' ডি ',' এ ',' বি ',' সি ',' 8 ',' 9 ',' ডি ']] (জেলিতে স্ট্রিংগুলি অক্ষরের তালিকায় রয়েছে)
  Unc আনর্ডার্ডড জোড়: [x, y] সমস্ত স্বতন্ত্র x, y এর জন্য এন। | [[['a', 'বি', 'সি', '1', '2', 'ডি', '5'], ['এ', 'বি', 'সি', '3', ' 4 ',' ডি ',' 3 ']], [[' 'এ', 'বি', 'সি', '1', '2', 'ডি', '5'], ['এ', ' বি ',' সি ',' ১ ',' ৪ ',' ডি ',' এ ',' বি ',' সি ',' ২ ',' ৩ ',' ডি ',' এ ',' খ ' , 'সি', '8', '9', 'ডি']], [['' এ ',' বি ',' সি ',' 3 ',' 4 ',' ডি ',' 3 '], ['এ', 'বি', 'সি', '১', '৪', 'ডি', 'এ', 'বি', 'সি', '২', '৩', 'ডি',
                        এখানে, স্বতন্ত্রভাবে, আমি বিভিন্ন অবস্থানের বলতে চাই। |
    µ) একটি monadic লিঙ্ক সহ মানচিত্র। |
     ṁ / ছাঁচ x এর মতো y। এটি, চক্র x এর দৈর্ঘ্য y না হওয়া পর্যন্ত until | [['' এ ',' বি ',' সি ',' ১ ',' ২ ',' ডি ',' ৫ '], [' এ ',' বি ',' সি ',' ১ ',' ২ ',' ডি ',' 5 ',' এ ',' বি ',' সি ',' ১ ',' ২ ',' ডি ',' ৫ ',' এ ',' বি ',' সি ', '1'], ['এ', 'বি', 'সি', '3', '4', 'ডি', '3', 'এ', 'বি', 'সি', '3', '4', 'ডি', '3', 'এ', 'বি', 'সি', '৩']]
       sḢL x x দৈর্ঘ্যের খণ্ডে বিভক্ত করুন। | [[['a', 'বি', 'সি', '1', '2', 'ডি', '5']], [['' এ ',' বি ',' সি ',' 1 ' , '2', 'ডি', '5'], ['এ', 'বি', 'সি', '1', '2', 'ডি', '5'], ['এ', ' বি ',' সি ',' ১ ']], [[' 'এ', 'বি', 'সি', '3', '4', 'ডি', '3'], ['এ', ' বি ',' সি ',' 3 ',' 4 ',' ডি ',' 3 '], [' এ ',' বি ',' সি ',' 3 ']]]
           এমনকি সম-সূচক খণ্ডগুলির কেস অদলবদল করুন (1-সূচকযুক্ত)। | [[['a', 'বি', 'সি', '1', '2', 'ডি', '5']], [['' এ ',' বি ',' সি ',' 1 ' , '2', 'ডি', '5'], ['এ', 'বি', 'সি', '1', '2', 'ডি', '5'], ['এ', ' বি ',' সি ',' ১ ']], [[' 'এ', 'বি', 'সি', '3', '4', 'ডি', '3'], ['এ', ' বি ',' সি ',' 3 ',' 4 ',' ডি ',' 3 '], [' এ ',' বি ',' সি ',' 3 ']]]
               এফ ফ্ল্যাটেন। | [['' এ ',' বি ',' সি ',' ১ ',' ২ ',' ডি ',' ৫ '], [' এ ',' বি ',' সি ',' ১ ',' ২ ',' ডি ',' 5 ',' এ ',' বি ',' সি ',' 1 ',' 2 ',' ডি ',' 5 ',' এ ',' বি ',' সি ', '1'], ['এ', 'বি', 'সি', '3', '4', 'ডি', '3', 'এ', 'বি', 'সি', '3', '4', 'ডি', '3', 'এ', 'বি', 'সি', '3']]
                n 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, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1]]]
                  The মানচিত্রটি শেষ করার পরে, প্রতিটি বুল (0 বা 1) অ্যারে যোগ করুন। | [[5], [17], [14]]
                   । সর্বোচ্চ। | 17
— মিঃ এক্সকোডার
সূত্র
আমি জেলির সাথে পুরোপুরি পরিচিত নই, তবে আমি মনে করি আপনি বাদ দিতে পারেন LÞএবং এখনও শেষে একই সর্বাধিক পেতে পারেন ।
— চ্যাস ব্রাউন
@ চ্যাসব্রাউন উগ, না, আমার এটি হওয়া উচিত । অন্যথায়, সবচেয়ে দীর্ঘতম দৈর্ঘ্যের প্যাডিংয়ের ṁ/পরিবর্তে কিছু ক্ষেত্রে সবচেয়ে দীর্ঘতম দৈর্ঘ্যকে ছাঁটাই করে দেবে, যা আমরা চাই না .... আমার ধারণা পরীক্ষার কেসগুলি খুব ভালভাবে বেছে নেওয়া হয়েছে (এবং এটি একটি বরং দুর্ভাগ্যজনক কাকতালীয় ঘটনা) ...
— মিঃ এক্সকোডার
@ চ্যাসব্রাউন উদাহরণ হিসাবে, চেষ্টা করুন ["AacaAc", "Aab"]।
— মিস্টার এক্সকোডার 21
আহ্ হ্যাঁ, আমি দেখছি ... আমাকে আরও কিছু শিখতে হবে জেলি ... :)
— চ্যাস ব্রাউন
5

পাইথন 2 , 86 বাইট

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)

এটি অনলাইন চেষ্টা করুন!

প্রদত্ত দুটি স্ট্রিং, s,t, zip((s+s.swapcase())*len(t),t))দৈর্ঘ্য tuples একটি তালিকা হবে len(t)যেহেতু zipসবচেয়ে কম iterable করার কাটছাঁট করে। যদি len(s)<len(t), তবে এই "প্যাড আউট" sকাঙ্ক্ষিত কেস অদলবদল সহ এবং আমরা sumপৃথক পৃথক অক্ষরের গণনা করি ।

যদি len(t)<=len(s), তবে ফলাফলটি যদি আমরা মূল্যায়ন করছিলাম তবে এর sumচেয়ে কম বা সমান হবে ; সুতরাং এই ক্ষেত্রে ফলাফলের উপর এর কোনও প্রভাব নেই ।sumt,smax

— চ্যাস ব্রাউন
সূত্র
আপনি 1 বাইট সংরক্ষণ করার y!=পরিবর্তে ব্যবহার করতে পারেন!=y
— মিস্টার এক্সকোডার
@জনাব. এক্সকোডার: থেক্স, তবে আমি আমার সমাধানটি মারাত্মকভাবে পুনর্বিবেচনা করে শেষ করেছি ...
— চ্যাস ব্রাউন
3

জেলি , 19 বাইট

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

এটি অনলাইন চেষ্টা করুন!

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.
— dylnan
সূত্র
2

রুবি , 89 82 বাইট

চ্যাস ব্রাউন এর উত্তরের অনুরূপ সদৃশ পদ্ধতি ব্যবহার করে প্রতিটি জোড়ের হামিং দূরত্ব গণনা করার আগে নিজের বিপক্ষে ইনপুট তালিকার ক্রস-প্রোডাক্ট তৈরি করে । রুবি অতিরিক্ত ওভারহেড ব্যতীত স্ট্রিংগুলি একসাথে জিপ করতে বা বুলেটিন যোগ করতে পারে না, সুতরাং তার পরিবর্তে ম্যানুয়ালি স্ট্রিংগুলির জোড়ার মাধ্যমে পুনরাবৃত্তি করা প্রয়োজন হয়ে পড়ে।

জিবি থেকে -7 বাইট।

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

এটি অনলাইন চেষ্টা করুন!

— মান কালি
সূত্র
1
— জিবি
2

জাভা 10 ,748 740 667 666 616 বাইট

এটি সবচেয়ে ঘন এবং অপঠনযোগ্য হতে হবে, তবুও আমি সবচেয়ে দীর্ঘতম গল্ফটি নিয়ে এসেছি।

h(String[])একটি সুস্পষ্ট অ্যারে (কোনও ভেরি আরগস নেই) সহ কল পদ্ধতি : যেমন,

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

আয় 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();}

আপনি এটি অনলাইন চেষ্টা করতে পারেন !

অবহেলিত এবং মন্তব্য করেছেন:

// 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();
}

আমি জানি একটি ভাল সমাধান অর্জন করা যেতে পারে, বিশেষত স্ট্রিং জুটির অংশের জন্য।

সম্পাদনা : hammingDistance()প্রদত্ত স্ট্রিংয়ের সংখ্যার স্কোয়ারে ইনট অ্যারের আকার পরিবর্তন করে 8 বাইট শেভ করুন । এটি ArrayIndexOutOfBoundsপরীক্ষার ক্ষেত্রে একটিতে ফেলে দেওয়াও ঠিক করে fix

সম্পাদনা 2 : কেভিন ক্রুইজসেনের মন্তব্যে 33 বাইট সংরক্ষণ করা হয়েছে : শ্রেণির ঘোষণা সরিয়ে দেওয়া হয়েছে, নামগুলি 1 চরকে সংক্ষিপ্ত করা হয়েছে, অপারেটরগুলি পরিবর্তন হয়েছে, ইত্যাদি etc.

সম্পাদনা 3 : 1 বাইট সংরক্ষণ করুন এবং ভের-আরগের সাহায্যে পদ্ধতি পরিবর্তন করে শয়তান-অনুমোদিত স্কোর এ পৌঁছান।

সম্পাদনা 4 : কেভিন ক্রুইজসেনকে আবারও 50 টি বাইট সংরক্ষণ করুন: varকীওয়ার্ড, মুছে ফেলা StringBuilderউদাহরণ ইত্যাদির জন্য 8 থেকে 10 পর্যন্ত জাভা সংস্করণ আপডেট করুন

— joH1
সূত্র
1
আমার প্রচুর সময় নেই, তবে গল্ফ করার জন্য কিছু প্রাথমিক বিষয়: ক্লাসটি ফেলে দিন, কেবলমাত্র পদ্ধতিগুলিই যথেষ্ট। সমস্ত পদ্ধতি এবং পরিবর্তনশীল নামগুলি একক বাইটে পরিবর্তন করুন .. সুতরাং hammingDistanceব্যবহারের পরিবর্তে dবা অন্য কোনও অব্যবহৃত ভেরিয়েবল। আপনার বেশিরভাগ &&হতে পারে &এবং ||হতে পারে |। c^' 'হতে পারে c^32। boolean w = false;হতে পারে boolean w=0>1;। i=0লুপ আরম্ভের সরানো হবে এবং পরিবর্তন করতে পারেন ,i,jথেকে ,i=0,j। ++jসরানো যেতে পারে এবং ++যোগ করা যেতে পারে .charAt(j++)। .toString()হতে পারে +""। for(j=i+1;j<l;++j)হতে পারে for(j=0;++j<l;)। ইত্যাদি ইত্যাদি
— কেভিন ক্রুইজসেন
1
জাভা golfing জন্য টিপস এবং <সমস্ত ভাষা> এ golfing জন্য টিপস পাশাপাশি মাধ্যমে পড়া আকর্ষণীয় হতে পারে। :)
— কেভিন ক্রুজসসেন
ধন্যবাদ! এটি কিছু চমৎকার বাইট-উত্তোলন। লিঙ্কগুলির জন্যও ধন্যবাদ, আমি এটি একবার দেখে নিচ্ছি এবং এটি সম্পাদনা করব!
— joH1
1
শয়তান-অনুমোদিত স্কোরের জন্য উন্নীত xD আরো কিছু ছোট জিনিস: StringBuilderহতে পারে StringBuffer(যদি আপনি জাভা 10 স্যুইচ এটা হতে পারে var b=new StringBuffer(l);দ্য। booleanএবং charতারপর এও হতে পারে varআপনি জাভা 10 স্থানীয়ভাবে না থাকে তাহলে। এটা Tio পাওয়া যায় )। এছাড়াও, for(;i<n;++i){for(char c:s.toCharArray())b.append(e(w,c));w=!w;}হতে পারে for(;i++<n;w=!w)for(char c:s.toCharArray())b.append(e(w,c));। এবং আমি পুরোপুরি নিশ্চিত যে আপনি StringBufferসম্পূর্ণরূপে সরিয়ে ফেলতে পারবেন এবং কেবল পরিবর্তে Stringএবং +=ব্যবহার করুন append।
— কেভিন ক্রুইজসেন
ম্যান, বেশ কয়েক মাসের ক্লিন কোড এবং ভাল কোডিং অনুশীলন আমাকে কীভাবে গল্ফ করতে হয় তা ভুলে গেছে! আমি আমার উত্তর আপডেট করব এবং টিআইও অন্তর্ভুক্ত করব।
— joH1
1

05 এ বি 1 ই , 33 29 বাইট

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

এটি অনলাইনে চেষ্টা করুন বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

সম্ভবত বাইট-কাউন্টে অর্ধেক করা যায়, তবে এটি কার্যকর হয় ..

ব্যাখ্যা:

Ć           # 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
— কেভিন ক্রুইজসেন
সূত্র
1

জাভা 11, 387 বাইট

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

এটি অনলাইনে চেষ্টা করুন। (দ্রষ্টব্য: যেহেতু জাভা ১১ টি এখনও টিআইও-তে নেই, একই বাইট-কাউন্ট String.repeat(int)হিসাবে অনুকরণ করা হয়েছে repeat(String,int)))

ব্যাখ্যা:

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
— কেভিন ক্রুইজসেন
সূত্র
1

আর , 173 বাইট

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

এটি অনলাইন চেষ্টা করুন!

@ জিএনএম: আমি আপনার কোডটি গল্ফ করার জন্য যথাসাধ্য চেষ্টা করেছি ( অবশ্যই আমার ভারী কাস্টমাইজেশন সহ ) তবে আপনি জানেন যে, স্ট্রিংগুলি সামাল দেওয়ার ক্ষেত্রে আর খুব চকচকে নয়: পি

— digEmAll
সূত্র
আমি বাজি ধরতে পারি এটি 150 বাইট হতে পারে, তবে আমি ঠিক জানি না কীভাবে এখনও।
— জিউসেপে
@ জিউসেপ: আমারও সন্দেহ আছে ... তবে আমি সংক্ষিপ্ত স্ট্রিং ম্যানিপুলেশন কোড লেখার ক্ষেত্রে সত্যই ভাল নই এবং আর আমাকে খুব একটা
— সাহায্যও
@ ডিগেম সমস্ত আমি নিজের চ্যালেঞ্জ সমাধানের চেষ্টা করতে যাচ্ছি না, তবে কয়েকটি outerসংমিশ্রণের সম্ভাবনা থাকতে পারে এবং এর পরিবর্তে কোড পয়েন্টগুলিতে মডুলার গাণিতিক করা সম্ভব হতে পারে chartr।
— এনজিএম
@ এমএনএম: সম্ভব ... আমি অঙ্কের গাণিতিক পদ্ধতির বিষয়টি বাতিল করে দিয়েছি কারণ সংখ্যার স্পর্শ না করে চিঠিগুলির ক্ষেত্রে কেস পরিবর্তন করার জন্য আমি একটি সংক্ষিপ্ত সমাধান / সূত্র খুঁজে পেলাম না ...
— digEmAll
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.