অনন্য সেটগুলি তৈরি করে এমন অ্যারেগুলি গণনা করুন

Question

এই প্রশ্নের একটি অ্যারের সন্ধান করতে অনুরূপ সেট আপ হয়েছে যা লক্ষ্যগুলির তুলনায় একেবারে পৃথক হলেও অঙ্কের একটি সেট ফিট করে ।

Aদৈর্ঘ্যের অ্যারে বিবেচনা করুন n। অ্যারেতে কেবল ধনাত্মক পূর্ণসংখ্যা থাকে। উদাহরণস্বরূপ A = (1,1,2,2)। আসুন f(A)এর সমস্ত শূন্য খালি মিলিত সাবহারির সমষ্টিগুলির সেট হিসাবে সংজ্ঞায়িত করি A। এই ক্ষেত্রে f(A) = {1,2,3,4,5,6}। উত্পাদনের পদক্ষেপগুলি f(A) নিম্নরূপ:

এর subarrays Aহয় (1), (1), (2), (2), (1,1), (1,2), (2,2), (1,1,2), (1,2,2), (1,1,2,2)। তাদের নিজ নিজ পরিমাণ হয় 1,1,2,2,2,3,4,4,5,6। এই তালিকা থেকে আপনি যে সেটটি পান তা তাই {1,2,3,4,5,6}।

আমরা অ্যারেটিকে A অনন্য বলি যদি Bএকই দৈর্ঘ্যের আর কোনও অ্যারে না থাকে f(A) = f(B)তবে অ্যারেটি Aবিপরীত হয়। উদাহরণ হিসাবে, f((1,2,3)) = f((3,2,1)) = {1,2,3,5,6}তবে দৈর্ঘ্যের অন্য কোনও অ্যারে নেই 3যা একই সংখ্যার যোগফল তৈরি করে।

আমরা কেবল অ্যারেগুলি বিবেচনা করব যেখানে উপাদানগুলি হয় প্রদত্ত পূর্ণসংখ্যা sবা s+1। যেমন s=1অ্যারে শুধুমাত্র থাকে 1এবং 2।

কার্য

একটি নির্দিষ্ট কাজের জন্য nএবং sসেই দৈর্ঘ্যের অনন্য অ্যারেগুলির সংখ্যা গণনা করা। আপনি অনুমান করতে পারেন sমধ্যে 1এবং 9।

আপনার অ্যারের বিপরীত পাশাপাশি অ্যারেটিও গণনা করা উচিত নয়।

উদাহরণ

s = 1, উত্তর সর্বদা n+1।

s = 2উত্তরগুলি গণনা n = 1করা হচ্ছে:

2,3,6,10,20,32,52,86

s = 8উত্তরগুলি গণনা n = 1করা হচ্ছে:

2,3,6,10,20,36,68,130

স্কোর

একটি প্রদত্ত জন্য nআপনার কোড সব মানের জন্য আউটপুট উত্তর দিতে sথেকে 1থেকে 9। আপনার স্কোর সর্বোচ্চ মান nযার জন্য এটি এক মিনিটের মধ্যে পূর্ণ হয়।

পরীক্ষামূলক

আমার উবুন্টু মেশিনে আপনার কোডটি চালাতে হবে তাই আপনার কোডটি কীভাবে সংকলন করতে এবং চালাতে হয় তার জন্য যথাসম্ভব বিস্তারিত নির্দেশাবলী অন্তর্ভুক্ত করুন।

লিডারবোর্ড

• এন = 24 মরচে (34 সেকেন্ড) এন্ডারস কাসের্গ দ্বারা লিখেছেন
• এন = 16 ক্লাস ইন ক্লিন (36 সেকেন্ড)
• কমন লিপ্পে (49 সেকেন্ড) জে রোয়ান দ্বারা n = 14

Comments

সুতরাং যদি s = 8 হয় তবে এটি 8 এবং 9 এর সমস্ত সম্ভাব্য সংমিশ্রণের অ্যারে, অন্য কিছু নয়?

— JRowan

@ জ্রোয়ান নং। আপনি সেই অ্যারেগুলির মধ্যে কোনওটিই গণনা করেন না যা অন্য কোনও অ্যারের মতো সমান পরিমাণে আছে।

— আনুশ

এই অংশটি সম্পর্কে আমি কিছুটা বিভ্রান্ত হয়ে পড়েছি আমরা কেবলমাত্র অ্যারেগুলিতে বিবেচনা করব যেখানে উপাদানগুলি হয় প্রদত্ত পূর্ণসংখ্যা s বা s + 1। উদাহরণস্বরূপ যদি s = 1 অ্যারেতে কেবল 1 এবং 2 থাকে So সুতরাং n যদি 2 হয় এবং s 3 হয় তবে অ্যারেটি কী হবে?

— JRowan

কি সম্পর্কে [3,3] এবং আমি বর্তমানে তালিকার বিপরীত মুছে ফেলছি। [3,4] -> [4,3]

— জোরোয়ান

@ রোসলুপ প্রথমত, আপনি অন্য প্রশ্নের উপরে পোস্টটি বোঝাতে চেয়েছিলেন এবং দ্বিতীয়ত, [3, 5, 4] একটি উপসেট তবে [3, 5, 1, 4] এর সাববারে নয় ।

— অ্যান্ডারস কাসের্গ

Answer 1

মরিচা , n ≈ 24

সুবিধাজনক reverse_bitsবৈশিষ্ট্যের জন্য রাতের জং প্রয়োজন । সঙ্গে কম্পাইল rustc -O unique.rsএবং (যেমন) চালানো ./unique 24।

#![feature(reverse_bits)]
use std::{collections::HashMap, env, mem, process};

type T = u32;
const BITS: u32 = mem::size_of::<T>() as u32 * 8;

fn main() {
    let args = env::args().collect::<Vec<_>>();
    assert!(args.len() == 2);
    let n: u32 = args[1].parse().unwrap();
    assert!(n > 0);
    assert!(n <= BITS);
    let mut unique = (2..=9).map(|_| HashMap::new()).collect::<Vec<_>>();
    let mut sums = vec![0 as T; n as usize];
    for a in 0 as T..=!0 >> (BITS - n) {
        if a <= a.reverse_bits() >> (BITS - n) {
            for v in &mut sums {
                *v = 0;
            }
            for i in 0..n {
                let mut bit = 1;
                for j in i..n {
                    bit <<= a >> j & 1;
                    sums[(j - i) as usize] |= bit;
                }
            }
            for s in 2..=9 {
                let mut sums_s =
                    vec![0 as T; ((n + (n - 1) * s) / BITS + 1) as usize].into_boxed_slice();
                let mut pos = 0;
                let mut shift = 0;
                let mut lo = 0;
                let mut hi = 0;
                for &v in &sums {
                    lo |= v << shift;
                    if BITS - shift < n {
                        hi |= v >> (BITS - shift);
                    }
                    shift += s;
                    if shift >= BITS {
                        shift -= BITS;
                        sums_s[pos] = lo;
                        pos += 1;
                        lo = hi;
                        hi = 0;
                    }
                }
                if lo != 0 || hi != 0 {
                    sums_s[pos] = lo;
                    pos += 1;
                    if hi != 0 {
                        sums_s[pos] = hi;
                    }
                }
                unique[s as usize - 2]
                    .entry(sums_s)
                    .and_modify(|u| *u = false)
                    .or_insert(true);
            }
        }
    }
    let mut counts = vec![n + 1];
    counts.extend(
        unique
            .iter()
            .map(|m| m.values().map(|&u| u as T).sum::<T>())
            .collect::<Vec<_>>(),
    );
    println!("{:?}", counts);
    process::exit(0); // Avoid running destructors.
}

Comments

এই মহান, আপনাকে ধন্যবাদ. এটি প্রায় 90 সেকেন্ডে n = 25 এর জন্য সম্পূর্ণ করে। তবে মূল সমস্যাটি হ'ল এটি আমার 8 জিবি র‌্যামের 70% ব্যবহার করে।

— আনুশ

হঠাৎ করেই আমি কিছু নিয়ে উদ্বিগ্ন হয়ে পড়েছি। আপনি কি পরীক্ষা করছেন যে অ্যারেগুলি অন্য সমস্ত সম্ভাব্য অ্যারেগুলির সাথে সম্মতিতে অনন্য, বা কেবল মানগুলি সহ sএবং সেগুলিতে রয়েছে s+1?

— আনুশ

@ আনুশ হ্যাঁ, আমি গতির জন্য কিছু স্মৃতি ব্যবহারের ব্যবসা করেছি। আমি এমন অ্যারেগুলি গণনা করছি যা মানগুলির সাথে অন্যান্য অ্যারেগুলিকে অনন্য করে তোলে sএবং s + 1(যেহেতু আপনি বলেছিলেন যে এগুলি কেবলমাত্র আমরা বিবেচনা করব), যদিও তা তাত্ক্ষণিকভাবে স্পষ্ট নয় যে এটি কোনও তাত্ক্ষণিক হবে কিনা।

— অ্যান্ডার্স কাসের্গ

আমি মনে করি আগামীকাল আমার এই কাজ করা দরকার। অ্যারে 1,1,2,2 এবং 1,1,1,3 উভয়ই 1,2,3,4,5,6 অঙ্কের সেট দেয়। তবে প্রাক্তনটি কেবল 1 এবং 2 দিয়ে অ্যারেগুলির মধ্যে অনন্য নয় তাই এখনই যদি এটি কোনও পার্থক্য করে তবে আমি কিছুটা বিভ্রান্ত am

— আনুশ

@ আনুশ এটি একটি পার্থক্য করে: 4 এর 1 এবং 2 দৈর্ঘ্যের অ্যারেগুলির মধ্যে [1, 2, 2, 2] এর অঙ্কগুলি অনন্য, তবে [1, 1, 2, 3] এর যোগফলের সমান।

— অ্যান্ডার্স কাসের্গ

Answer 2

কমন লিস্প এসবিসিএল, এন = 14

কল ফাংশন (goahead এনএস)

    (defun sub-lists(l m &optional(x 0)(y 0))
  (cond; ((and(= y (length l))(= x (length l)))nil)
        ((= y (length l))m)
        ((= x (length l))(sub-lists l m 0(1+ y)))
    (t (sub-lists l (cons(loop for a from x to (+ x y)

             when (and(nth (+ x y)l)(nth a l)(< (+ x y)(length l)))
                ;   while (nth a l)
             ;while(and(< (+ x y)(length l))(nth a l))
                    collect (nth a l))m) (1+ x)y))
    ))
(defun permutations(size elements)
  (if (zerop size)'(())
 (mapcan (lambda (p)
                    (map 'list (lambda (e)
                           (cons e p))
                         elements))
     (permutations (1- size) elements))))
(defun remove-reverse(l m)
  (cond ((endp l)m)
    ((member (reverse (first l))(rest l) :test #'equal)(remove-reverse (rest l)m))
    (t (remove-reverse (rest l)(cons (first l)m)))))
(defun main(n s)
  (let((l (remove-reverse (permutations n `(,s ,(1+ s)))nil)))

  (loop for x in l
     for j = (remove 'nil (sub-lists x nil))
       collect(sort (make-set(loop for y in j
        collect (apply '+ y))nil)#'<)
     )
  ))
(defun remove-dups(l m n)
  (cond ((endp l)n)
        ((member (first l) (rest l) :test #'equal)(remove-dups(rest l)(cons (first l) m) n))
    ((member (first l) m :test #'equal)(remove-dups(rest l)m n))
    (t(remove-dups (rest l) m (cons (first l) n))))

  )
(defun goahead(n s)
  (loop for a from 1 to s
  collect(length (remove-dups(main n a)nil nil))))
(defun make-set (L m)
  "Returns a set from a list. Duplicate elements are removed."
  (cond ((endp L) m)
    ((member (first L) (rest L)) (make-set (rest L)m))
    ( t (make-set (rest L)(cons (first l)m)))))

এখানে রান সময়

CL-USER> (time (goahead 14 9))
Evaluation took:
  34.342 seconds of real time
  34.295000 seconds of total run time (34.103012 user, 0.191988 system)
  [ Run times consist of 0.263 seconds GC time, and 34.032 seconds non-GC time. ]
  99.86% CPU
  103,024,254,028 processor cycles
  1,473,099,744 bytes consed

(15 1047 4893 6864 7270 7324 7328 7328 7328)
CL-USER> (time (goahead 15 9))
Evaluation took:
  138.639 seconds of real time
  138.511089 seconds of total run time (137.923824 user, 0.587265 system)
  [ Run times consist of 0.630 seconds GC time, and 137.882 seconds non-GC time. ]
  99.91% CPU
  415,915,271,830 processor cycles
  3,453,394,576 bytes consed

(16 1502 8848 13336 14418 14578 14594 14594 14594)

Comments

আমি কীভাবে এটি চালাব? আমি কি আপনার কোডটি কোনও ফাইলে অনুলিপি করব এবং sbclকোনওভাবে কল করব ?

— আনুশ

আমি ইম্যাক্স এবং স্লাইম ব্যবহার করি তবে আপনি এটি ফাইল ডিরেক্টরিতে টেস্ট.লিস্প এবং এসবিসিএল প্রম্পতে আপনার ডিরেক্টরি কল (লোড "টেস্ট.লিস্প") এ রেখে দিতে পারেন এবং তারপরে আমার কীভাবে এটি ফাংশনটি কল করবেন

— জেআরওয়ান

Answer 3

পরিষ্কার

অবশ্যই সর্বাধিক দক্ষ পদ্ধতির নয়, তবে একজন নির্দোষ বাই-ভ্যালু ফিল্টার কতটা ভাল করে তা দেখতে আমি আগ্রহী।

এটি বলেছিল, এই পদ্ধতিটি ব্যবহার করে এখনও কিছুটা উন্নতি করতে হবে।

module main
import StdEnv, Data.List, System.CommandLine

f l = sort (nub [sum t \\ i <- inits l, t <- tails i])

Start w
	# ([_:args], w) = getCommandLine w
	= case map toInt args of
		[n] = map (flip countUniques n) [1..9]
		_ = abort "Wrong number of arguments!"

countUniques 1 n = inc n
countUniques s n = length uniques
where
	lists = [[s + ((i >> p) bitand 1) \\ p <- [0..dec n]] \\ i <- [0..2^n-1]]
	pairs = sortBy (\(a,_) (b,_) = a < b) (zip (map f lists, lists))
	groups = map (snd o unzip) (groupBy (\(a,_) (b,_) = a == b) pairs)
	uniques = filter (\section = case section of [a, b] = a == reverse b; [_] = True; _ = False) groups

নামের একটি ফাইলে রাখুন main.icl, বা উপরের লাইনটি এতে পরিবর্তন করুন module <your_file_name_here>।

সংকলন clm -h 1500m -s 50m -fusion -t -IL Dynamics -IL StdEnv -IL Platform main।

আপনি শিরোনামের লিঙ্কটি থেকে টিআইও (এবং আমার) সংস্করণটি ব্যবহার করতে পারেন বা এখান থেকে আরও একটি সাম্প্রতিক ।

Comments

আমি মনে করি না এই কোডটি সঠিক আউটপুট দেয়। আমি এস = 8 দিয়ে চেষ্টা করেছিলাম এবং এটি [9,86,126,130,130,130,130,130,130] দেয়

— আনুশ

@ আনুশ হুম আমি জানি আমি এটি পরীক্ষা করেছি। আমি দেখতে পাচ্ছি যে আমি এবং পোস্ট করা পোস্টটির মধ্যে কিছু পরিবর্তন করেছি, আমাকে কয়েক ঘন্টা দিন এবং আমি আমার বিরতিতে এটি করতে পারি।

— ousurous

@ আনুশ আপনি সরবরাহ করছেন কেন s? যে প্রশ্নে আপনি বলেছেন " একটি প্রদত্ত এন এর জন্য , আপনার কোডের 1 এর 9 থেকে সমস্ত মানের জন্য উত্তর আউটপুট করা উচিত"

— 5urous

আমি মনে করি এটিই আপনি আমার মস্তিষ্ককে হিমশীতল বলছেন :) আমি এখন আপনার কোডটি সময় করব।

— আনুশ