এর সাবস্ট্রিংগুলি থেকে একটি স্ট্রিং সনাক্ত করুন

20

ভূমিকা

আমি এর আগে দু'টি চ্যালেঞ্জ তৈরি করেছি যেখানে ধারণাটি যতটা সম্ভব ক্যোয়ারী-টাইপ অপারেশন ব্যবহার করে কোনও বস্তুর পুনর্গঠন করা; এটি তৃতীয় হবে।

কাজটি

আপনার ইনপুটগুলি Sবর্ণমালা abcএবং তার দৈর্ঘ্যের উপর একটি খালি খালি স্ট্রিং হবে এবং আপনার আউটপুট হবে S। কোনও বিধিনিষেধ না থাকলে এটি অবশ্যই একটি তুচ্ছ কাজ হবে; ধরাটি হ'ল আপনাকে Sসরাসরি অ্যাক্সেসের অনুমতি দেওয়া হয়নি । কেবলমাত্র আপনাকে Sযা করার অনুমতি দেওয়া হয়েছে তা হ'ল ফাংশনটি কল করা num_occur(T, S), যেখানে Tঅন্য কিছু স্ট্রিং রয়েছে এবং এতে num_occurউপস্থিতির সংখ্যা গণনা করা Tহয় S। ওভারল্যাপিং ঘটনার স্বতন্ত্র হিসাবে গণনা করা হয়, তাই num_occur(T, S)সত্যিই সূচকের সংখ্যা ফেরৎ iযেমন যে

S[i, i+1, …, i+length(T)-1] == T

উদাহরণস্বরূপ, num_occur("aba", "cababaababb")ফিরে আসবে 3। নোটও যে num_occur(S, S)ফিরে আসবে 1। এর ফলাফলটি num_occur("", S)অনির্ধারিত, এবং আপনাকে খালি স্ট্রিংয়ে ফাংশনটি কল করা উচিত নয়।

সংক্ষেপে, আপনার একটি ফাংশন বা প্রোগ্রাম লিখতে হবে যা ইনপুট হিসাবে গ্রহণ করে Sএবং কিছু সংক্ষিপ্ত স্ট্রিং এবং কিছু বার length(S)কল num_occurকরে S, Sসেই তথ্য থেকে পুনর্গঠন করে এবং তা ফেরত দেয়।

বিধি এবং স্কোরিং

আপনার লক্ষ্য হ'ল একটি প্রোগ্রাম লিখুন যা num_occurযতটা সম্ভব কম কল করে । ইন এই সংগ্রহস্থলের , আপনি একটি ফাইল নামক পাবেন abc_strings.txt। ফাইল 100 স্ট্রিং নিজস্ব লাইনে প্রতিটি লেন্থ 50 এবং 99. মধ্যে রয়েছে তোমার সংগ্রহ কল মোট সংখ্যা num_occurএই ইনপুট উপর , নিম্ন স্কোর ভাল হচ্ছে। আপনার সমাধানটি এই সংখ্যাটি চলার সাথে সাথে এটিকে ট্র্যাক করে রাখবে এবং শেষ হওয়ার পরে এটি মুদ্রণ করবে। স্ট্রিংগুলি থেকে অভিন্ন র্যান্ডম চিঠিগুলি বেছে নিয়ে উত্পন্ন হয় abc; আপনি স্ট্রিং উৎপাদিত এই পদ্ধতির জন্য নিখুত অনুমোদিত, কিন্তু না স্ট্রিং নিজেদের।

কোনও সময়সীমা নেই, কেবলমাত্র জমা দেওয়ার আগে পরীক্ষার ক্ষেত্রে আপনার সমাধানটি চালানো উচিত। আপনার সমাধানটি Sকেবল পরীক্ষার ক্ষেত্রে নয়, কোনও বৈধ ইনপুট জন্য কাজ করা উচিত ।

আপনি num_occurযদি অন্য কারও ব্যবহার না করেন তবে আপনার বাস্তবায়নটি ভাগ করে নিতে উত্সাহিত হন । বলটি ঘূর্ণায়মান হওয়ার জন্য, পাইথনে এটি প্রয়োগ করা হয়েছে:

def num_occur(needle, haystack):
    num = 0
    for i in range(len(haystack) - len(needle) + 1):
        if haystack[i : i + len(needle)] == needle:
            num += 1
    return num
string  fewest-operations 
— Zgarb
সূত্র
আমাদের অ্যালগরিদমগুলিকে সমস্ত সম্ভাব্য স্ট্রিংয়ের জন্য কাজ করতে হবে S, বা কেবল পরীক্ষার ক্ষেত্রে?
— লুভজো
@ লভজো ভাল প্রশ্ন। তাদের তাত্ত্বিকভাবে সমস্ত খালি খালি স্ট্রিংয়ের জন্য কাজ করা উচিত। আমি চ্যালেঞ্জ সম্পাদনা করব।
— জাগারব
all non-empty stringsযে দৈর্ঘ্যের?
— edc65
@ edc65 তাত্ত্বিকভাবে হ্যাঁ। সীমাবদ্ধ মেমরি ঠিকানা এবং অন্যান্য ব্যবহারিক সীমাবদ্ধতা উপেক্ষা করতে পারেন।
— জাগারব
সাফল্যের সাথে মূল্যায়ন পরীক্ষায় উত্তীর্ণ হওয়ার জন্য একটি ভিডাব্লু অ্যালগরিদম যুক্ত করা সম্ভব: abc_strings.txt এর জানা স্ট্রিংগুলির ঘটনার জন্য প্রথমে চেক করুন
— এমমানুয়েল

উত্তর:

6

জাভাস্ক্রিপ্ট, 14325 14311 কল

আমরা একটি খালি স্ট্রিং দিয়ে শুরু করি এবং আমাদের কমপক্ষে একটি ম্যাচ থাকা অবস্থায় এখনও শেষ বা বর্তমান স্ট্রিংয়ের শুরুতে একটি নতুন চিঠি যুক্ত করে পুনরাবৃত্তির সাথে এগিয়ে চলেছি।

পূর্ববর্তী সমস্ত ফলাফল অবজেক্টে numOccur()সংরক্ষিত হয়েছে symএবং সম্ভাব্য প্রার্থী হতে পারে না এমন কোনও নতুন স্ট্রিং তত্ক্ষণাত প্রত্যাখ্যান করার জন্য আমরা এই ডেটা ব্যবহার করি।

সম্পাদনা : যেহেতু আমরা সর্বদা শুরু 'a'করি, আমরা aস্ট্রিংয়ের সঠিক সংখ্যাটি সবসময় জানি । প্রক্রিয়াটি শেষ করতে আমরা এই তথ্যটি ব্যবহার করি যখন আমরা সনাক্ত করি যে কেবলমাত্র একটি ক্রম aঅনুপস্থিত। এছাড়াও নিয়মিত প্রকাশটি স্থির করে যা ক্রোম এবং আইই-তে অবৈধ।

var test = [
  'ccccbcbbbbacbaaababbccaacbccaaaaccbccaaaaaabcbbbab',
  // etc.
];
var call = 0;

function guess(S, len) {
  var sym = {};
  recurse(S, len, "", sym);
  return sym.result;
}

function recurse(S, len, s, sym) {
  var dictionary = [];

  if(s == '' || (isCandidate(s, sym) && (sym[s] = numOccur(S, s)))) {
    if(s.length == len) {
      sym.result = s;
    }
    else if(sym['a'] && count(s, 'a') == sym['a'] - (len - s.length)) {
      dictionary = [ Array(len - s.length + 1).join('a') ];
    }
    else {
      dictionary = [ "a", "b", "c" ];
    }
    dictionary.some(function(e) {
      return recurse(S, len, s + e, sym) || recurse(S, len, e + s, sym);
    });
    return true;
  }
  return false;
}

function isCandidate(s, sym) {
  return sym[s] === undefined && Object.keys(sym).every(function(k) {
    return count(s, k) <= sym[k];
  });
}

function count(s0, s1) {
  return (s0.match(new RegExp(s1, 'g')) || []).length;
}

function numOccur(S, s) {
  call++;
  return count(S, s);
}

test.forEach(function(S) {
  if(guess(S, S.length) != S) {
    console.log("Failed for: '" + S + "'");
  }
});
console.log(call + " calls");

নীচে সম্পূর্ণ নির্বাহযোগ্য স্নিপেট et

কোড স্নিপেট দেখান

— Arnauld
সূত্র
"সংক্ষেপে, আপনার একটি ফাংশন বা প্রোগ্রাম লিখতে হবে যা [...], এস তথ্য থেকে এস পুনর্গঠন করে এবং তা ফেরত দেয় " "
— কার্লকাস্টোর
@ কার্লকাস্টার - ওফস তুমি ঠিক বলছো. এটা ঠিক আছে। ধন্যবাদ!
— আর্নৌল্ড
4

পাইথন, 15205 কল

def findS(S, len_s, alphabeth = "abc"):
    if len_s == 0:
        return ""
    current = ""
    add_at_start = True
    while len(current) < len_s:
        worked = False 
        for letter in alphabeth:
            if add_at_start:
                current_new = current + letter
            else:
                current_new = letter + current
            if num_occur(current_new, S) > 0:
                current = current_new
                worked = True
                break
        if not worked:
            add_at_start = False
    return current

এই জমাটি সম্ভবত সাবঅপটিমাল, কারণ এটি কেবল num_occurস্ট্রিংয়ের একটি সাবস্ট্রিং কিনা তা পরীক্ষা করতে ব্যবহার করে Sএবং এটি সাবস্ট্রিংয়ের পরিমাণ গণনা করতে কখনই ব্যবহার করে না।

অ্যালগরিদম একটি স্ট্রিং সংরক্ষণকারী করে কাজ করে currentযা সমান হতে পর্যন্ত নির্মিত হয় Sশেষ। অ্যালগরিদমের সমস্ত পদক্ষেপ এখানে:

  1. আমরা currentসমান সেট''

  2. বর্ণমালা প্রতিটি অক্ষর মাধ্যমে যান, এবং নিম্নলিখিত করুন:

    2.1। একটি নতুন স্ট্রিং তৈরি করুন current_newএবং এটি currentঅক্ষরের পরে সমান সেট করুন ।

    2.2। এটি চালিয়ে current_newঅন্তর্ভুক্ত করা হয়েছে কিনা তা পরীক্ষা করুন এবং ফলাফলটি একের চেয়ে বেশি কিনা তা দেখুন।Snum_occur

    2.3। যদি current_newএতে অন্তর্ভুক্ত থাকে তবে Sসেট currentকরুন current_newএবং ২ য় ধাপে ফিরে যান se অন্যথায়, আমরা পরবর্তী চিঠিতে যাব।

  3. দৈর্ঘ্যের দৈর্ঘ্যের currentসমান হলে Sআমরা বলতে পারি যে আমাদের হয়ে গেছে। অন্যথায়, আমরা দ্বিতীয় ধাপে ফিরে যাই, তবে পরিবর্তে current_newবর্ণের সমান করতে 2.1 পদক্ষেপটি সংশোধন করি current। আমরা আবার এই পদক্ষেপে পৌঁছে, আমরা সম্পন্ন করা হয়।

— Loovjo
সূত্র
1
পাইপের জন্য লুপের অন্য একটি ধারা রয়েছে। এটি এর জন্য উপযুক্ত ব্যবহারের কেস হবে।
— জাকুব
4

পাইথন 2, 14952 14754 কল

প্রথম উত্তরের সাথে খুব সমান, তবে পরবর্তী অক্ষরগুলির চেষ্টা করবেন না যার ফলশ্রুতি অসম্ভব সাবস্ট্রিংগুলির:

  • আমরা জানি num_occurযে তারা লক্ষ্যতে ঘটে না (পূর্ববর্তী কলগুলি থেকে)

  • আমরা ইতিমধ্যে সাবস্ট্রিংটি এর চেয়ে বেশি প্রায়ই ব্যবহার করেছি already num_occur

(এক মিনিটের মধ্যে সাবস্ট্রিংগুলির গণনা যোগ করবে) সম্পন্ন

def get_that_string(h,l,alpha = "abc"):
    dic = {}
    s = ""
    ##costs 1 additional call per example, but its worth it
    char_list = [num_occur(j,h) for j in alpha[:-1]]
    char_list.append(l - sum(char_list))
    for y, z in zip(char_list,alpha):
        dic[z] = y
    end_reached = False
    while len(s) < l:
        for t in alpha:
            if not end_reached:
                neu_s = s + t
                substrings = [neu_s[i:]   for i in range(len(neu_s))]
            else:
                neu_s = t + s
                substrings = [neu_s[:i+1] for i in range(len(neu_s))]
            ## Test if we know that that can't be the next char
            all_in_d = [suff for suff in substrings if suff in dic.keys()]
            poss=all(map(dic.get,all_in_d))
            if poss:
                if not neu_s in dic.keys():
                    dic[neu_s] = num_occur(neu_s,h)
                if dic[neu_s] > 0:
                    s=neu_s
                    for suff in all_in_d:
                        dic[suff] -= 1
                    break
        else:
            end_reached = True
    ##print s
    return s


## test suite start
import urllib

def num_occur(needle, haystack):
    global calls
    calls += 1
    num = 0
    for i in range(len(haystack) - len(needle) + 1):
        if haystack[i : i + len(needle)] == needle:
            num += 1
    return num

calls = 0
url = "https://raw.githubusercontent.com/iatorm/random-data/master/abc_strings.txt"
inputs = urllib.urlopen(url).read().split("\n")
print "Check: ", inputs == map(lambda h: get_that_string(h, len(h)), inputs)
print "Calls: ", calls
— KarlKastor
সূত্র
4

পাইথন 12705 12632 কল

  1. 2 টি অক্ষরের স্ট্রিং সংঘটনগুলির একটি তালিকা তৈরি করুন
  2. তালিকাটি বাছাই করুন
  3. প্রথমে সবচেয়ে সম্ভাব্য চরিত্রটি ব্যবহার করে স্ট্রিংটি তৈরি করুন, কেবলমাত্র একটি সম্ভাবনা আছে কিনা তা পরীক্ষা করবেন না don't
  4. তালিকা আপডেট করুন
  5. যদি তালিকাটি খালি থাকে তবে এটি দ্বিতীয় ধাপে শেষ

আমি লুভজো ফাংশন কঙ্কাল ব্যবহার করেছি। পাইথনে আমি কখনই কোড করি না আমার বুটস্রেপ দরকার

সম্পাদনা:
একটি অক্ষরের দৈর্ঘ্যের স্ট্রিংয়ের জন্য
যুক্ত কোডগুলি ইতিমধ্যে ম্যাচের নিদর্শনগুলি প্রত্যাখ্যান করতে কোড যুক্ত করা হয়েছে

def finds(S):

    if len(S) == 0:
            return ""
    if len(S) == 1 
            if num_occur("a",S) == 1 :
                         return "a"
            if num_occur("b",S) == 1 :
                         return "b"
            return "c"
    tuples=[]
    alphabet=[ "aa", "ab", "ac", "ba", "bb", "bc", "ca", "cb"]
    for s in alphabet : tuples.append( (num_occur(s,S), s) )

    sum=0
    for (i,s) in tuples :   sum+=i
    tuples.append( (len(S)-sum-1, "cc") )
    tuples.sort(key=lambda x:(-x[0],x[1]))

    (i, current) = tuples[0]
    tuples[0] = (i-1, current)

    add_at_start = True
    nomatch=[]
    while len(tuples) > 0:
            worked = False
            tuples.sort(key=lambda x:(-x[0],x[1]))
            count=0
            if not add_at_start :
                    for (n, s) in tuples :
                            if s[0]==current[-1:] :         count+=1
            for i in range(len(tuples)):
                    (n, s)=tuples[i]
                    if add_at_start:
                            if current[0] == s[1] :
                                    current_new = s[0] + current
                                    possible=True
                                    for nm in nomatch :
                                            lng=len(nm)
                                            if current_new[0:lng] == nm :
                                                    possible=False
                                                    break
                                    if possible and num_occur(current_new, S) > 0:
                                            current = current_new
                                            worked = True
                                    else :
                                            nomatch.append(current_new)
                    else:
                            if current[-1:] == s[0] :
                                    current_new =  current + s[1]
                                    possible=True
                                    for nm in nomatch :
                                            lng=len(nm)
                                            if current_new[-lng:] == nm :
                                                    possible=False
                                                    break
                                    if count == 1 or (possible and num_occur(current_new, S) > 0) :
                                            current = current_new
                                            worked = True
                                    else :
                                            nomatch.append(current_new)
                    if worked :
                            if n == 1:
                                    del tuples[i]
                            else    :
                                    tuples[i] = (n-1, s)
                            break
            if not worked:
                    add_at_start = False
    return current
— এমানুয়েল
সূত্র
আপনার বর্ণমালায় 'সিসি' নেই?
— স্পার
@ স্পার "সিসি" গণনা করা হয়, এটি 100 টি কল সংরক্ষণ করে: up tuples.append ((লেন (এস) -সুম -1, "সিসি")) `
— এমমানুয়েল
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.