সংখ্যার লেজিকাল পার্টিশন সাজানো

17

চ্যালেঞ্জটি সত্যিই সহজ: একটি সংখ্যা দেওয়া হয়েছে, আপনি এর অঙ্কগুলি ছোট সংখ্যার একটি অ্যারেতে বিভক্ত করেছেন যে ফলস্বরূপ সংখ্যাগুলি হ্রাস পাচ্ছে না। ক্যাচটি হ'ল আপনাকে এটিকে এমনভাবে বিভক্ত করতে হবে যাতে অ্যারের দৈর্ঘ্য সর্বাধিক।

বিভ্রান্ত?

  • আপনাকে STDIN (বা নিকটতম বিকল্প), কমান্ড-লাইন আর্গুমেন্ট বা কোনও সুবিধাজনক, দ্ব্যর্থহীন ইনপুট ফর্ম্যাটে ফাংশন আর্গুমেন্টের মাধ্যমে একটি ইতিবাচক পূর্ণসংখ্যা দেওয়া হবে।
  • আপনাকে সংখ্যার দশমিক সংখ্যাগুলি সুসংগত, বিচ্ছিন্ন গোষ্ঠীতে বিভক্ত করতে হবে।
  • এই সংখ্যাগুলির গোষ্ঠীগুলির দ্বারা প্রতিনিধিত্ব করা সংখ্যার অ্যারেগুলি গোষ্ঠীগুলি পুনরায় সাজানো ছাড়াই (সাধারণত, ক্রমহ্রাসমান ক্রমে) বাছাই করা উচিত ।
  • এমন ক্ষেত্রে যেখানে এই জাতীয় একাধিক পার্টিশন উপস্থিত রয়েছে, আপনাকে ইনপুটটিকে যথাসম্ভব বিভাজন করতে হবে। সম্পর্কের ক্ষেত্রে, এরকম একটি ফলাফল ফিরিয়ে দিন।
  • আপনি অ্যারেটিকে STDOUT (বা নিকটতম বিকল্প) বা ফাংশন রিটার্ন মান হিসাবে আউটপুট করতে পারেন। STDOUT (বা নিকটতম বিকল্প) এর ক্ষেত্রে অ্যারেটি কোনও সুবিধাজনক, দ্ব্যর্থহীন তালিকা বিন্যাসে মুদ্রণ করা উচিত।
  • বিভাজন সংখ্যার নেতৃস্থানীয় জিরো থাকা উচিত নয়। সুতরাং উদাহরণস্বরূপ 1002003হয় [1, 002, 003]বা হিসাবে প্রিন্ট করা যাবে না [1, 2, 3]এবং এটির জন্য একমাত্র বৈধ উত্তর [100, 2003]।

পরীক্ষার কেস:

123456 -> [1, 2, 3, 4, 5, 6]
345823 -> [3, 4, 5, 8, 23]
12345678901234567890 -> [1, 2, 3, 4, 5, 6, 7, 8, 90, 123, 456, 7890]
102 -> [102]
302 -> [302]
324142 -> [3, 24, 142] OR [32, 41, 42]
324142434445 -> [32, 41, 42, 43, 44, 45]
1356531 -> [1, 3, 5, 6, 531]
11121111111 -> [1, 1, 1, 2, 11, 11, 111]
100202003 -> [100, 202003]

স্কোরিং

এটি কোড-গল্ফ তাই বাইট জেতে সংক্ষিপ্ততম কোড।

code-golf  number  combinatorics  set-partitions 
— অপ্টিমাইজার
সূত্র

উত্তর:

10

পাইথ, 34

FNyUz#aYmv:zhdedC,+0N+NlzB)efqSTTY

এটি এখানে অনলাইনে চেষ্টা করুন । লক্ষ্য করুন, এটিতে ও (এন) এর একটি সময় (এবং স্থান) জটিলতা রয়েছে। সুতরাং পরীক্ষার 12345678901234567890কেসটি অনলাইন সংকলকটিতে খুব বেশি সময় নেয়। পরিবর্তে অফলাইনটি ব্যবহার করুন (আমার ল্যাপটপে 1 মিনিট)।

এটি আমার প্রথম প্রচেষ্টা। উন্নতির জন্য কিছু জায়গা থাকতে পারে।

আমার অ্যালগরিদম কীভাবে কাজ করে তা প্রথমে কিছু ধারণা।

  • আমি ইনপুটটি স্ট্রিং হিসাবে ব্যাখ্যা করি, সংখ্যা হিসাবে নয়।
  • তারপরে আমি সমস্ত সম্ভাব্য সাবসেট তৈরি করি [0, 1, 2, ..., len(n-1)]
  • এই প্রতিটি সাবসেটের জন্য (নেওয়া যাক [1, 4, 5]), আমি এই সংখ্যাগুলি ব্যবহার করে ইনপুট স্ট্রিংটিকে অংশে বিভক্ত করি। [input[0:1], input[1, 4], input[4,5], input[5,len(input)]]।
  • এর পরে আমি এই সংখ্যাগুলিকে স্ট্রিংয়ে রূপান্তরিত করার চেষ্টা করি। দুটি সমস্যা হতে পারে। পাইথ (বা পাইথন) খালি স্ট্রিংয়ের জন্য এবং সংখ্যার একটি স্ট্রিং দিয়ে শুরু করে একটি ব্যতিক্রম ছুঁড়ে 0। অতএব আমি একটি try - catchব্লক ব্যবহার করি (তাত্ক্ষণিক বিরতির সাথে আসলে অনন্ত লুপ)। রূপান্তরটি যদি সফলভাবে হয়, তবে আমি ফলাফলকে একটি তালিকায় যুক্ত করি Y।
  • আমি সমস্ত সাবসেট পরিচালনা করার পরে, Yফলাফলগুলির জন্য তালিকাটি ফিল্টার করি , যা ইতিমধ্যে বাছাই করা হয়েছে এবং শেষটি মুদ্রণ করে (সর্বশেষে সর্বাধিক গ্রুপ রয়েছে)।

এখন বিস্তারিত ব্যাখ্যা: 

                            Implicit: z = input() (z is a String!)
                                      Y = empty list
FNyUz                       for each subset N of [0, 1, 2, ..., len(z)-1]:

     #                         start try-catch block (actually an infinite loop, 
                               but the Python implementation uses a try catch. 

      aY                          append to Y:
                C,+0N+Nlz            zip([0] + N, N + [len(z)])
        m                            map each element d to
          :zhded                     z[d[0]:d[-1]]
         v                           evaluated
                         B        if this didn't throw an exception already, end the infinite loop
                          ) end for loop   

 f    Y      filter Y for elements T, for which
  qSTT           sorted(T) == T
e            and print the last one (the subsets generated with yUz are sorted 
             by length, so the last one has the most groups)
— Jakube
সূত্র
আপনি এর aYপরিবর্তে~Y]
— FryAmTheEggman
@FryAmTheEggman আমি সবসময় ভুলে a। কেন জানি না।
— জাকুবে
@ জাকুব সম্ভবত এটি ডক্সে না থাকার কারণে?
— Sp3000
আমি 45 ডলার অক্ষর জন্য একটি সমাধান ছিল। আমি int("01")পাইথের ত্রুটি হওয়ার বিষয়টি সম্পর্কে অবগত ছিলাম না (পাইথনে এটি ঘটে না)।
— orlp
3
@ জাকুবে হা হা, যদিও যৌক্তিক মনে হয় তবে সাধারণত ইনপুটটির nদৈর্ঘ্য।
— অপটিমাইজার
6

গণিত, 134 127 বাইট

এটি কার্যকরভাবে অক্ষম কারণ এটি বৈধের চেয়ে অনেক বেশি পার্টিশন তৈরি করে। 324142434445পরীক্ষা ক্ষেত্রে কয়েক সেকেন্ডের মধ্যে সঞ্চালিত হয়, কিন্তু আমি চেষ্টা না 12345678901234567890।

f/@Last@Select[Needs@"Combinatorica`";f=FromDigits;SetPartitions[d=IntegerDigits@#],0<=##&@@f/@#&&Join@@#==d&&#~FreeQ~{0,__}&]&

এটি একটি নামবিহীন ফাংশন সংজ্ঞায়িত করে যা একটি পূর্ণসংখ্যা নেয় এবং পূর্ণসংখ্যার একটি তালিকা প্রদান করে।

ব্যাখ্যা

এই কোডটি পড়ার ক্রমটি পুরো জায়গাগুলিতে কিছুটা, তাই আমি এটি পড়ার ইচ্ছাকৃত ক্রমটি ভেঙে দেব (এবং বেশিরভাগ অংশের জন্য মূল্যায়ন করা):

  • d=IntegerDigits@#ইনপুট এর দশমিক সংখ্যা পেতে এবং এই তালিকাতে নির্ধারণ করুন d।

  • SetPartitions(যার প্রয়োজন Needs@"Combinatorica`";) আমাকে এর সমস্ত পার্টিশন দেয়। যাইহোক, এটি আমার চেয়ে অনেক বেশি ফেরত দেয় কারণ এটি ইনপুটটিকে সেট হিসাবে বিবেচনা করে । এটি এটিকে অদক্ষ করে তোলে তবে আমি এটি ব্যবহার করছি কারণ সমস্ত তালিকার পার্টিশন পেতে আমার সবচেয়ে সংক্ষিপ্ততম উপায়টি আরও দীর্ঘ। উদাহরণস্বরূপ, তালিকাটি যদি {1, 2, 3}ফাংশনটি ফিরে আসত:

    {{{1, 2, 3}}, {{1}, {2, 3}}, {{1, 2}, {3}}, {{1, 3}, {2}}, {{1}, {2}, {3}}}

    লক্ষ করুন যে ক) ধারাবাহিক পার্টিশনগুলি সমস্ত সঠিক ক্রমে থাকে এবং খ) পার্টিশনগুলি মোটা থেকে সেরা পর্যন্ত সাজানো হয়।

  • Select[...,...&] তারপরে এই তালিকাটি ফিল্টার করে বেনামে ফাংশনটি দ্বিতীয় আর্গুমেন্ট হিসাবে পাস করেছে।
    • Join @@ # == d পরীক্ষা করে দেখা যায় যে আমরা একটি সাধারণ সেট পার্টিশনের পরিবর্তে একটি তালিকা পার্টিশন পেয়েছি।
    • #~FreeQ~{0, __} কোনও পার্টিশন একটি শীর্ষস্থানীয় শূন্য দিয়ে শুরু হয় না তা পরীক্ষা করে।
    • 0 <= ## & @@ f /@ #এটি আরও কিছুটা অস্পষ্ট। FromDigitsসংখ্যা দ্বারা প্রতিনিধিত্ব করা সংখ্যাগুলি পুনরুদ্ধার করার জন্য প্রথমে আমরা পার্টিশনের প্রতিটি তালিকায় ম্যাপ করি । তারপরে আমরা 0 <= ##সেই সংখ্যাগুলিতে প্রয়োগ করি , যেখানে ##সমস্ত সংখ্যা বোঝায়। যদি পার্টিশনটি হয় {1, 23, 45}তবে এটি প্রসারিত হয় 0 <= 1 <= 23 <= 45, সুতরাং এটি অ্যারে বাছাই করে তা পরীক্ষা করে।
  • Last@তারপরে ফিল্টারিংয়ের পরে আমাকে শেষ পার্টিশনটি দেয় - এটি কাজ করে কারণ SetPartitionsইতিমধ্যে পার্টিশনগুলি বাছাই করা হয়েছে, যেমন সেরাগুলি শেষের দিকে।
  • পরিশেষে, f/@সংখ্যা তালিকা থেকে নম্বরগুলি উদ্ধার করে।
— মার্টিন ইন্ডার
সূত্র
5

পাইথন 3, 134 বাইট

def f(s,n=0,L=[],R=[],i=0):
 while s[i:]:i+=1;m=int(s[:i]);R=max([f(s[i:],m,L+[m]),R][m<n or"1">s[i:]>"":],key=len)
 return[L,R][s>""]

এটা একটু অগোছালো, তবে ওহ ভাল। প্রোগ্রামটি কেবল পুনরাবৃত্তভাবে সমস্ত বৈধ পার্টিশন উত্পন্ন করে। মজার অংশটি হ'ল নেতৃস্থানীয় জিরোগুলিকে অস্বীকার করার জন্য যা ছিল তা ছিল অতিরিক্ত or "1">s[i:]>""শর্ত।

এর মতো ইনপুট নেয় f("12345678901234567890")এবং ইনটগুলির একটি তালিকা প্রদান করে।

— Sp3000
সূত্র
4

Pyth, 62 61 60

JlzKkef&qJsml`dTqTSTolNmmibTcjKsC,z+m>Ndt>+*J]0jk2_JKNU^2-J1

ব্যাখ্যা

অ্যালগরিদম 0(ইনক্লুসিভ) এবং 2^(n-1)(এক্সক্লুসিভ) এর মধ্যে সমস্ত বাইনারি সংখ্যা উত্পন্ন করে কাজ করে যেখানে nইনপুটটির দৈর্ঘ্য।

প্রত্যেকের বাইনারি অঙ্কগুলি তারপরে N1 এর জন্য একটি বিভাজক ( ) এ ম্যাপ করা হয় এবং 0 এর জন্য কিছুই হয় না।

এই অক্ষরগুলি পরে প্রতিটি ইনপুট চরিত্রের মধ্যে সন্নিবেশ করা হয়, এবং ফলাফলটি ভাগ করে Nএকটি তালিকা তৈরি করে।

তালিকাগুলির মানগুলি পরে পূর্ণসংখ্যায় পার্স করা হয় এবং তালিকাগুলি দৈর্ঘ্য অনুসারে বাছাই করা হয়। তারপরে যা অবশিষ্ট রয়েছে তা হ'ল অ-বাছাই করাগুলি এবং শীর্ষস্থানীয় জিরোগুলিতে বিভক্ত হওয়াগুলি ফিল্টার করা, যার পরে দীর্ঘতম তালিকাটি বেছে নেওয়া হয়।

Jlz                                                   set J to len(input)
Kk                                                    set K to ""
e                                                     take the last of:
 f&                                                    only take lists where:
   qJsml`dT                                             sum of string lengths of items
                                                        is equal to length of input and
           qTST                                         list is in order
               olN                                       sort by length
                  m                                       map k over...
                   mibT                                    convert items to int (base-10)
                       c                        N           split by N
                        jK                                   join by ""
                          s                                   sum to combine tuples
                           C,z                                 zip input with
                              +                K                append [""] for equal lengths
                               m>Nd                              replace 1 with N, 0 with ""
                                   t                              take all but first
                                    >        _J                    take len(input) last values
                                     +                              pad front of binary with
                                      *J]0                           [0] times input's length
                                          jk2                        current k in binary
                                                 U^2-J1  range 0..2^(len(input)-1)-1
— PurkkaKoodari
সূত্র
1

(কোন প্রতিযোগিতা) পাইথ, 25 বাইট

ef&&Fmnhd\0T.A<V=NsMTtN./

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

কিভাবে এটা কাজ করে:

ef&&Fmnhd\0T.A<V=NsMTtN./  Q = eval(input())
                         ./  all partitions of Q
 f                       ./  filter all partitions of Q where:
  &                            both:
   &Fmnhd\0T                     neither substring starts with "0"
                               and:
            .A<V=NsMTtN          all entries are less than their proceeding ones
e                            returns the last amongst the filtered partitions
— ফুটো নুন
সূত্র
0

জে, 109 বাইট

খুব দীর্ঘ তবে কমপক্ষে ও (এন * (2 এন)!) মেমরি এবং ও (এন * লগ (এন) * (2 এন)!) সময় লাগে যেখানে এন ইনপুটটির দৈর্ঘ্য। (সুতরাং এটি 5 টিরও বেশি সংখ্যক দিয়ে চালানোর চেষ্টা করবেন না))

f=.3 :0
>({~(i.>./)@:(((-:/:~)@(#$])*#)@>))<@".(' 0';' _1')rplc"1~(#~y-:"1' '-."#:~])(i.!2*#y)A.y,' '#~#y
)

ফাংশনটি স্ট্রিং হিসাবে ইনপুট নেয়।

উদাহরণ:

   f every '5423';'103';'1023'
  5 423
103   0
 10  23

পদ্ধতি:

  • দৈর্ঘ্যের হিসাবে ইনপুটটিতে একই সংখ্যক স্পেস যুক্ত করুন।
  • এটি প্রতিটি সম্ভাব্য উপায়ে পারম्यूट করুন।
  • ফাঁকাবিহীন স্ট্রিংটি ইনপুটটির সমান কিনা তা পরীক্ষা করুন (অর্থাত এটি এটির একটি বিভাজন)।
  • নেতৃস্থানীয় শূন্য সমাধানকে অবৈধ করতে '0 এর' থেকে '_1 এর প্রতিস্থাপন করুন।
  • প্রতিটি স্ট্রিং মূল্যায়ন।
  • সর্বাধিক দীর্ঘতম তালিকাটি সন্ধান করুন। এটি প্রত্যাবর্তনের মান।
— randomra
সূত্র
0

হাস্কেল, 161 বাইট

(#)=map
f[x]=[[[x]]]
f(h:t)=([h]:)#f t++(\(a:b)->(h:a):b)#f t
g l=snd$maximum[(length x,x::[Int])|x<-[read#y|y<-f l,all((/='0').head)y],and$zipWith(>=)=<<tail$x]

পরীক্ষা রান:

*Main> mapM_ (print . g) ["123456","345823","12345678901234567890","102","302","324142","324142434445","1356531","11121111111","100202003"]
[1,2,3,4,5,6]
[3,4,5,8,23]
[1,2,3,4,5,6,7,8,90,123,456,7890]
[102]
[302]
[32,41,42]
[32,41,42,43,44,45]
[1,3,5,6,531]
[1,1,1,2,11,11,111]
[100,202003]

এটি কীভাবে কাজ করে: সহায়ক ফাংশন fসাবলিস্টের প্রতিটি সম্ভাব্য তালিকায় ইনপুট তালিকাটি বিভক্ত করে। gপ্রথমে সাবলিস্ট দিয়ে শুরু করে 0এবং যথাযথ ক্রম ছাড়াই তাদের বাতিল করে দেয় ards প্রতিটি অবশিষ্ট তালিকাটি দৈর্ঘ্যের সাথে যুক্ত করুন, সর্বাধিক নিন এবং আবার দৈর্ঘ্যের অংশটি বাতিল করুন।

— nimi
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.