ট্যাক্স ইতিহাসবিদ

Question

ভূমিকা

একজন কর আদায়কারী রয়েছেন যাঁকে তাঁর রাজ্যের কর পরিচালনায় কিছুটা সমস্যা হয়: historicalতিহাসিক রেকর্ডগুলি একটি দুর্দান্ত আগুনে পুড়ে গেছে।

তিনি জানতে চান যে বর্তমান অর্থ উত্তরাধিকার সূত্রে প্রাপ্ত উত্তরাধিকার সূত্রে কতগুলি সম্ভাব্য পেস্ট থাকতে পারে। ভাগ্যক্রমে, তাঁর রাজত্ব খুব সাধারণ।

রাজ্যটি 2 ডি বুলিয়ান ম্যাট্রিক্সের দ্বারা মডেল করা যেতে পারে, যেখানে lঅর্থ উত্তরাধিকার সূত্রে প্রাপ্ত Oকাউকে প্রতিনিধিত্ব করে এবং যার নেই তার প্রতিনিধিত্ব করে। উদাহরণ স্বরূপ:

l O l l

O O O l

l O l O

O O O l

(এটি সর্বদা একটি আয়তক্ষেত্র হবে)

পরবর্তী প্রজন্মের মধ্যে, রাজ্যটি ছোট (নেকড়েদের শক্তিশালী!)।

পরবর্তী প্রজন্মটি এর মতো দেখতে হবে, পূর্ববর্তী প্রজন্মের উপর সুপারিশ করা ( xপরবর্তী প্রজন্মের বংশধরদের জন্য স্থানধারক)

l O l l
 x x x
O O O l
 x x x
l O l O
 x x x
O O O l

একজন বংশধর পূর্বপুরুষদের যে সরাসরি তাদের চারপাশে আছে তাকান হবে (সুতরাং উপরের বাম xদেখতে হবে { l, O, O, O}, একটি নামক Unaligned আয়তক্ষেত্রাকার আশপাশ )

যদি কেবল একজন পূর্বপুরুষের উত্তরাধিকার সূত্রেই অর্থ উত্তরাধিকার সূত্রে প্রাপ্ত হয় তবে বংশধর তাদের কাছ থেকে অর্থ উত্তরাধিকারী হবে। যদি একাধিক পূর্বপুরুষের উত্তরাধিকার সূত্রে অর্থ প্রাপ্তি হয় তবে তারা ঝগড়া করবে এবং বংশধররা উত্তরাধিকারসূত্রে অর্থ উত্তরাধিকার সূত্রে শেষ হবে না। কেউ যদি উত্তরাধিকারসূত্রে অর্থ উত্তরাধিকারসূত্রে না থাকে তবে বংশধর কোনও অর্থ উত্তরাধিকারী হবে না।

(একাধিক বংশধর এক পূর্বপুরুষের উত্তরাধিকারী হতে পারে)

সুতরাং, পরবর্তী প্রজন্মের মতো দেখতে হবে:

​
 l l O

 l l O

 l l O
​

চ্যালেঞ্জ

ইনপুট

প্রজন্মের বর্তমান অবস্থা, যে কোনও দুটি স্বতন্ত্র মানের অ্যারের অ্যারে হিসাবে, যেখানে অভ্যন্তরীণ অ্যারেগুলি একই দৈর্ঘ্যের।

উদাহরণস্বরূপ, উপরের উদাহরণস্বরূপ, এটি হতে পারে:

[
  [True, True, False],
  [True, True, False],
  [True, True, False]
]

আউটপুট

পূর্বের প্রজন্মের ইনপুট যেখানে অনন্য পূর্ববর্তী প্রজন্মের সংখ্যার প্রতিনিধিত্ব করে একটি পূর্ণসংখ্যা।

আপনি ধরে নিতে পারেন যে উত্তরটি সর্বদা 2 ^ 30 - 1. (বা 1073741823) এর চেয়ে কম হবে।

পূর্ববর্তী প্রজন্মকে একটি "প্রিমাইজ" বলা হবে এবং এই চ্যালেঞ্জটি প্রাক প্রিমেসগুলি গণনা করা হবে ।

স্কোরিং

এটা একটা দ্রুততম-কোড চ্যালেঞ্জ, সুতরাং প্রতিটি জমা আমার কম্পিউটারে পরীক্ষা করা হবে, এবং জমা দেওয়ার ক্ষেত্রে কমপক্ষে সময় লাগে এটি বিজয়ী হবে।

উদাহরণ ইনপুট এবং আউটপুট

( 1যে উত্তরাধিকারী অর্থ উত্তরাধিকার সূত্রে প্রাপ্ত, এবং উত্তরাধিকারী যিনি অর্থের উত্তরাধিকারী হন 0নি)

ইনপুট:

[[1, 0, 1],
 [0, 1, 0],
 [1, 0, 1]]

আউটপুট:

4

ইনপুট:

[[1, 0, 1, 0, 0, 1, 1, 1],
 [1, 0, 1, 0, 0, 0, 1, 0],
 [1, 1, 1, 0, 0, 0, 1, 0],
 [1, 0, 1, 0, 0, 0, 1, 0],
 [1, 0, 1, 0, 0, 1, 1, 1]]

আউটপুট:

254

ইনপুট:

[[1, 1, 0, 1, 0, 1, 0, 1, 1, 0],
 [1, 1, 0, 0, 0, 0, 1, 1, 1, 0],
 [1, 1, 0, 0, 0, 0, 0, 0, 0, 1],
 [0, 1, 0, 0, 0, 0, 1, 1, 0, 0]]

আউটপুট:

11567

Comments

আমি প্রথম পৃষ্ঠাটি খোলার সময় "loolLooOOLLololOLLOLOLOLOLOLOLOLL" আমি যা দেখেছি তা হ'ল।

— ম্যাজিক অক্টোপাস উরান

Answer 1

সি ++ বুডিডি লাইব্রেরি ব্যবহার করে

বাইনারি সিদ্ধান্ত ডায়াগ্রামের সাথে খেলতে এটি দুর্দান্ত বাহানা বলে মনে হয়েছিল । রাজ্যটি একটি বড় বুলিয়ান সূত্রে রূপান্তরিত হয় যেখানে আমাদের সন্তুষ্ট হতে পারে এমন কয়েকটি সংখ্যার গুনতে হবে। এটি (কখনও কখনও) এটির চেয়ে বেশি দক্ষতার সাথে করা যায়।

কিংডম অবশ্যই ফ্ল্যাট অ্যারে এবং স্পষ্টতই প্রদত্ত মাত্রাগুলি হিসাবে একটি প্রোগ্রাম ধ্রুবক হিসাবে দেওয়া উচিত। (পাঠকের জন্য এক্সপিস হিসাবে চমৎকার ইনপুটটি বাকি রয়েছে :-)

বিব্রতকরভাবে সহজ কোডটি এখানে:

#include <iostream>
#include <bdd.h>

// describe the kingdom here:

constexpr int ROWS = 4;
constexpr int COLS = 10;

constexpr int a[] = {
   1, 1, 0, 1, 0, 1, 0, 1, 1, 0,
   1, 1, 0, 0, 0, 0, 1, 1, 1, 0,
   1, 1, 0, 0, 0, 0, 0, 0, 0, 1,
   0, 1, 0, 0, 0, 0, 1, 1, 0, 0,
};

// end of description

// check dimensions
static_assert(ROWS*COLS*sizeof(int)==sizeof(a),
          "ROWS*COLS must be the number of entries of a");

// dimensions of previous generation
constexpr int R1 = ROWS+1;
constexpr int C1 = COLS+1;

// condition that exactly one is true
bdd one(bdd a, bdd b, bdd c, bdd d){
  bdd q = a & !b & !c & !d;
  q |= !a & b & !c & !d;
  q |= !a & !b & c & !d;
  q |= !a & !b & !c & d;
  return q;
}

int main()
{
  bdd_init(1000000, 10000); // tuneable, but not too important
  bdd_setvarnum(R1*C1);
  bdd q { bddtrue };
  for(int j=COLS-1; j>=0; j--) // handle high vars first
    for (int i=ROWS-1; i>=0; i--){
      int x=i+R1*j;
      bdd p=one(bdd_ithvar(x), bdd_ithvar(x+1),
                bdd_ithvar(x+R1), bdd_ithvar(x+R1+1));
      if (!a[COLS*i+j])
        p = !p;
      q &= p;
    }
  std::cout << "There are " << bdd_satcount(q) << " preimages\n";
  bdd_done();
}

ডিবিয়ান 8 (জেসি) দিয়ে সংকলন করতে, ইনস্টল করুন libbdd-devএবং করুন g++ -std=c++11 -o hist hist.cpp -lbdd। (অপ্টিমাইজিং অপশনগুলি প্রায় কোনও পার্থক্য করে না কারণ আসল কাজটি লাইব্রেরিতে করা হয়))

বড় উদাহরণগুলি আবর্জনা সংগ্রহ সম্পর্কে বার্তা নিয়ে যেতে পারে। তারা দমন করা যেতে পারে, তবে আমি তাদের দেখতে পছন্দ করি।

bdd_satcountএকটি doubleপ্রদান করে তবে ফলাফলের প্রত্যাশিত পরিসরের জন্য এটি যথেষ্ট ভাল। সঠিক (বড়) পূর্ণসংখ্যার সাহায্যে একই গণনা কৌশল সম্ভব।

কোডটির জন্য অনুকূলিত ROWS<COLS। আপনার যদি কলামগুলির চেয়ে অনেক বেশি সারি থাকে তবে ম্যাট্রিক্স স্থানান্তর করা ভাল ধারণা হতে পারে।

Comments

2.39 সেকেন্ড। এই যে আমার ছিল অর্ধেক সময়! এটি স্বীকৃত হিসাবে চিহ্নিত করা হচ্ছে।

— আর্টিয়ার

@ আর্টিয়ার: আপনি কি দীর্ঘকাল ধরে চলমান লুকানো পরীক্ষার কেস পোস্ট করবেন? পাশাপাশি আপনি চাইলে আপনার সমাধান।

— অ্যান্ড্রু এপস্টাইন

@ অ্যান্ড্রুএপস্টেইন আমি সম্প্রতি একটি হার্ডড্রাইভ ব্যর্থতা পেয়েছি এবং কোড এবং মূল পরীক্ষার কেস উভয়ই হারিয়েছি (সেগুলির মধ্যে শত শত ছিল এবং সেগুলি সর্বোচ্চ 300-প্রশস্ত, আমার মনে হয় 10-উচ্চ)। দুঃখিত।

— আরটিয়ার

Answer 2

পাইথন 2.7

এটি একটি নির্বোধ প্রথম প্রচেষ্টা is এটি বিশেষত দ্রুত নয়, তবে এটি সঠিক।

প্রথম পর্যবেক্ষণটি হ'ল প্রতিটি ঘর পূর্ববর্তী প্রজন্মের ঠিক চারটি কোষের উপর নির্ভরশীল। আমরা চারটি বিট সংখ্যা (0-15) হিসাবে এই চারটি ঘরকে উপস্থাপন করতে পারি। নিয়ম অনুসারে, পূর্ববর্তী প্রজন্মের ঠিক যদি একটি প্রতিবেশী সেল হয় 1, তবে বর্তমান প্রজন্মের একটি প্রদত্ত সেল হবে 1, অন্যথায়, এটি হবে 0। এগুলি দুটি শক্তির সাথে মিলিত, যথা [1, 2, 4, 8],। যখন চারটি পূর্বসূরিকে 4-বিট সংখ্যা হিসাবে উপস্থাপন করা হয়, অন্য যে কোনও সংখ্যা 0বর্তমান প্রজন্মের ফলাফল হিসাবে দেখাবে । এই তথ্য সহ, বর্তমান প্রজন্মের একটি ঘর দেখে, আমরা পূর্ববর্তী প্রজন্মের আশেপাশের সম্ভাবনাগুলি যথাক্রমে চার বা বারোটি সম্ভাবনার মধ্যে একটিতে সংকুচিত করতে পারি।

আমি নীচে প্রতিবেশী প্রতিনিধিত্ব করতে বেছে নিয়েছি:

32
10

যেখানে 0 হল সর্বনিম্ন-তাত্পর্যপূর্ণ বিট এবং আরও কিছু।

দ্বিতীয় পর্যবেক্ষণটি হ'ল বর্তমান প্রজন্মের দুটি সংলগ্ন কক্ষের জন্য, পূর্ববর্তী প্রজন্মের দুটি পাড়া ওভারল্যাপ করে:

32  32
10  10

বা:

32
10

32
10

অনুভূমিক ক্ষেত্রে, 2বাম পাশের দিকটি 3ডান পাড়া থেকে ডানদিকে এবং একইভাবে 0বাম দিকে এবং ডানদিকে ওভারল্যাপ হয় 1। উল্লম্ব ক্ষেত্রে, 1উপরের পাড়া 3থেকে নীচের অংশে উপরের সাথে ওভারল্যাপ হয় এবং একইভাবে 0উপরের এবং 2নীচে উপরের সাথে ।

এই ওভারল্যাপটির অর্থ হ'ল আমরা ইতিমধ্যে যেটি বেছে নিয়েছি তার উপর ভিত্তি করে আমরা এখনও অ-অজানা আশপাশের অঞ্চলের সম্ভাবনাগুলি সঙ্কুচিত করতে পারি can কোডটি বাম থেকে ডানে, উপরে থেকে নীচে, সম্ভাব্য পূর্বরূপগুলির জন্য পুনরাবৃত্তির গভীরতা-প্রথম অনুসন্ধানে এটির কাজ করে। নিম্নলিখিত চিত্রটি নির্দেশ করে যে কোনও বর্তমান ঘরের সম্ভাব্য আশপাশগুলি দেখার সময় আমাদের পূর্ববর্তী কোন পাড়াগুলি বিবেচনা করতে হবে:

f = free choice
h = only have to look at the neighborhood to the left
v = only have to look at the neighborhood to the top
b = have to look at both left and top neighborhoods

[f, h, h, h, h],
[v, b, b, b, b],
[v, b, b, b, b],
[v, b, b, b, b]

কোডটি এখানে:

def good_horizontal(left, right):
    if (left & 4) >> 2 != (right & 8) >> 3:
        return False
    if left & 1 != (right & 2) >> 1:
        return False
    return True


def good_vertical(bottom, top):
    if (bottom & 8) >> 3 != (top & 2) >> 1:
        return False
    if (bottom & 4) >> 2 != (top & 1):
        return False
    return True


ones = [1, 2, 4, 8]
zeros = [0, 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15]
h = {}
v = {}

for i in range(16):
    h[i] = [j for j in range(16) if good_horizontal(i, j)]
    v[i] = [j for j in range(16) if good_vertical(i, j)]


def solve(arr):
    height = len(arr)
    width = len(arr[0])

    if height == 1 and width == 1:
        if arr[0][0] == 1:
            return 4
        else:
            return 12
    return solve_helper(arr)


def solve_helper(arr, i=0, j=0, partial=None):
    height = len(arr)
    width = len(arr[0])

    if arr[i][j] == 1:
        poss = ones
    else:
        poss = zeros

    if i == height - 1 and j == width - 1:  # We made it to the end of this chain
        if height == 1:
            return sum([1 for p in poss if p in h[partial[-1][-1]]])
        else:
            return sum([1 for p in poss if partial[-2][-1] in v[p] and p in h[partial[-1][-1]]])

    if j == width - 1:
        new_i, new_j = i + 1, 0
    else:
        new_i, new_j = i, j + 1

    if i == 0:
        if j == 0:
            # first call
            return sum([solve_helper(arr, new_i, new_j, [[p]]) for p in poss])
        # still in the first row
        return sum([solve_helper(arr, new_i, new_j, [partial[0] + [p]]) for p in poss if p in h[partial[0][-1]]])
    if j == 0:  # starting a new row
        return sum([solve_helper(arr, new_i, new_j, [r for r in partial + [[p]]]) for p in poss if partial[i - 1][0] in v[p]])
    return sum([solve_helper(arr, new_i, new_j, [r for r in partial[:-1] + ([partial[-1] + [p]])]) for p in poss if p in h[partial[i][-1]] and partial[i - 1][j] in v[p]])

এটি চালানোর জন্য:

test3 = [
    [1, 1, 0, 1, 0, 1, 0, 1, 1, 0],
    [1, 1, 0, 0, 0, 0, 1, 1, 1, 0],
    [1, 1, 0, 0, 0, 0, 0, 0, 0, 1],
    [0, 1, 0, 0, 0, 0, 1, 1, 0, 0]
]

expected3 = 11567

assert(solve(test3) == expected3)

Comments

গোপন পরীক্ষার কেসগুলি করতে দীর্ঘ সময় নিচ্ছে, তাই আমি এই জমাটি স্কোর করছি না। একটি ভিন্ন অ্যালগরিদম চেষ্টা করুন, কারণ এতে সময়ের জটিলতা অনেক বেশি (এটি O(<something>^n)আমার মনে হয়)

— আরটিয়ার