আমি কি বালতিগুলি আবার চালু করতে পারি?


30

আমার ছোট্ট বাচ্চাটির একটি খেলনা রয়েছে:

সারিবদ্ধ

এই খেলনাটিতে 10 টি স্ট্যাকেবল ছোট বালতি রয়েছে, যা আমরা 1 (সবচেয়ে ছোটটি) থেকে 10 (বৃহত্তমতম) হতে চলেছি। কখনও কখনও সে ছোট ছোট স্তূপ তৈরি করে এবং খেলনাটি এভাবে শেষ হয়:

বিক্ষিপ্ত

আমরা স্কিম্যাটিকভাবে পাইলগুলি এর মতো উপস্থাপন করতে পারি:

      1  6
4  9  2  7
5  10 3  8
----------  <-- Floor
1  2  3  4  <-- Pile #

অথবা, এটি অন্যভাবে রাখুন:

[[4,5],[9,10],[1,2,3],[6,7,8]]

এই বালতি পাইলসের সেটটি সহজেই প্রথম টুকরো টুকরো টুকরো করে বড় বালতিগুলির পাইলসের ভিতরে রেখে ছোট ছোট বালতিগুলির পাইলগুলি রেখে মূল সেটটি (প্রথম চিত্রটি) পুনর্নির্মাণে সহজেই পুনরুদ্ধারযোগ্য:

                             1                            1  6
                             2                            2  7
      1  6                   3        6                   3  8
4  9  2  7                   4  9     7                   4  9
5  10 3  8                   5  10    8                   5  10
---------- > [Pile 3 to 1] > ---------- > [Pile 4 to 2] > ---------- > [Pile 1 to 2] > Done!
1  2  3  4                   1  2  3  4                   1  2  3  4

তবুও, কখনও কখনও আমার বাচ্চা টাওয়ারগুলি তৈরি করার চেষ্টা করে, বা বালতিগুলি ফেলে দেয় এবং পাইলগুলি বেমানান হয়ে যায় এবং আসল সেটটি কেবল একটি গাদা অন্যটির ভিতরে রেখে পুনরায় তৈরি করা যায় না। এর উদাহরণ:

[[1,3,2],[4]] (the kid tried to build a tower by placing a bigger bucket
               over a smaller one, we would need to reorder the buckets
               first)
[[1,3,4],[2]] (the kid left aside an unordered bucket, we would need to remove
               bucket #1 from pile #1 before restacking)
[[1,2,3],[5]] (the kid lost a bucket, we need to find it first)

চ্যালেঞ্জ

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

  • প্রতিটি স্ট্যাকের জন্য উপরে থেকে নীচে বালতিগুলি উপস্থাপন করে পূর্ণসংখ্যার তালিকার তালিকা হিসাবে ইনপুট দেওয়া হবে।
  • খালি আরম্ভের পাইলস থাকবে না (আপনি [[1,2,3],[],[4,5]]ইনপুট হিসাবে পাবেন না )।
  • বালতিগুলির মোট সংখ্যা যুক্তিসঙ্গত পূর্ণসংখ্যার ব্যাপ্তির মধ্যে যে কোনও হতে পারে।
  • আমার বাচ্চাটির কেবল একটি সেট বালতি রয়েছে যাতে সদৃশ উপাদান থাকবে না।
  • আপনি সত্যবাদী বা মিথ্যা জন্য যে কোনও দুটি সুসংগত (এবং সুসংগত) মান নির্বাচন করতে পারেন।
  • বালতিগুলি # 1 থেকে #N পর্যন্ত লেবেল করা হবে, Nপূর্ণসংখ্যার তালিকার বৃহত্তম পূর্ণসংখ্যা হিসাবে। আমার বাচ্চাটি এখনও শূন্য ধারণাটি জানে না।
  • আপনি যেকোন যুক্তিসঙ্গত ফর্ম্যাটে ইনপুটটি পেতে পারেন যতক্ষণ না এটি বালতিগুলির স্তূপের একটি সেট প্রতিনিধিত্ব করে আপনি যদি ইনপুটটি পাওয়ার উপায়টি পরিবর্তন করেন তবে কেবল আপনার উত্তরে এটি উল্লেখ করুন।
  • এটি , তাই প্রতিটি ভাষার জন্য সংক্ষিপ্ততম প্রোগ্রাম / ফাংশন জিতে যেতে পারে!

উদাহরণ

Input:  [[4,5],[9,10],[1,2,3],[6,7,8]]
Output: Truthy

Input:  [[6,7,8,9,10],[1],[2],[3,4,5],[11,12,13]]
Output: Truthy

Input:  [[2,3,4],[1],[5,6,7]]
Output: Truthy

Input:  [[1,2],[5,6],[7,8,9]]
Output: Falsey (buckets #3 and #4 are missing)

Input:  [[2,3,4],[5,6,7]]
Output: Falsey (bucket #1 is missing)

Input:  [[1,3,4],[5,7],[2,6]]
Output: Falsey (non-restackable piles)

Input:  [[1,4,3],[2],[5,6]]
Output: Falsey (one of the piles is a tower)

এটি স্যান্ডবক্স থেকে আসে ।
চার্লি

2
@ Mr.Xcoder না, ডুপ্লিকেট উপাদানের হবে না (আমার ছাগলছানা শুধুমাত্র বাকেট এক সেট এবং তারা সব আলাদা।
চার্লি

1
আমরা কি ধরে নিতে পারি যে বালতি 1 কখনই অনুপস্থিত?
পূর্কাকুডারী

2
@ পিটু ১৯৯৮ বালতি # 1 অনুপস্থিত হতে পারে, আমি সবেমাত্র একটি পরীক্ষার কেস যুক্ত করেছি (আসলে, সবচেয়ে ছোট বালটি হারাতে সহজ))
চার্লি

1
হ্যানয়ের বিভিন্ন টাওয়ার চ্যালেঞ্জগুলি এর সাথে সম্পর্কিত (সদৃশ নয়)।
অ্যাডমবর্কবর্ক

উত্তর:


12

জেলি , 6 5 বাইট

1 লাইট সংরক্ষণ করার জন্য @ লিনকে ধন্যবাদ।

ṢFµJ⁼

এটি অনলাইন চেষ্টা করুন! (টেস্ট-স্যুট ফুটারের সাথে আসে)

ব্যাখ্যা

ṢFµJ⁼    Main link. Argument: piles
Ṣ          Sort the piles by the size of the top bucket.
 F         Stack the piles, putting the left one to the top.
   J       See what a full pile with this many buckets would look like.
    ⁼      See if that looks like the pile you built.

আমি মনে করি ṢFµJ⁼কাজ করে তবে আমি সব ধরণের কেস নিয়ে ভাবিনি।
লিন

@ লিন এটি ধরে নিয়েছে যে বালতিটি 1অনুপস্থিত। আমি নিশ্চিত নই যে এটি ওপি দ্বারা গ্যারান্টিযুক্ত কিনা।
পূর্কাকাডারী

@ লিন বালতি # 1 অনুপস্থিত হতে পারে, হ্যাঁ। আমি সবেমাত্র একটি নতুন পরীক্ষার কেস যুক্ত করেছি।
চার্লি

যদি বালতিগুলি অনুপস্থিত থাকে, তবে সাজানো তালিকায় সর্বদা প্রত্যাখ্যানের চেয়ে বড় সংখ্যক থাকবে J, মিথ্যা আউটপুট গ্যারান্টি দিয়ে। আমি কিছু অনুপস্থিত করছি?
লিন

আমি মনে করি আপনি এখনও বালতি # 1 নিখোঁজ থাকা 5 বাইট সংস্করণ ব্যবহার করতে পারেন?
এরিক দি আউটগল্ফার

8

পাইথন 2 , 53 52 বাইট

বাইট xnor জন্য ধন্যবাদ

lambda x:sum(sorted(x),[0])==range(len(sum(x,[]))+1)

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


আমি যোগফল শুরু করতে চাই []। বেশ
কৌতূহলী

2
আপনি যোগফলটি শুরু করে একটি বাইট সংরক্ষণ করতে পারেন [0]যাতে ব্যাপ্তিটি শুরু হতে পারে 0
xnor

5

জাভাস্ক্রিপ্ট (ES6), 59 58 বাইট

a=>!(a.sort((a,[b])=>a[i=0]-b)+'').split`,`.some(v=>v-++i)

ব্যাখ্যা

a=>                                                        // given a 2D-array 'a'
     a.sort((a,[b])=>a[i=0]-b)                             // sort by first item
                              +''                          // flatten
    (                            ).split`,`                // split again
                                           .some(v=>v-++i) // i such that a[i] != i+1?
   !                                                       // true if none was found

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




5

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

import Data.List
(<[1..]).concat.sort

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

সংগৃহীত বাছাই করা তালিকা অসীম তালিকার তুলনায় অভিধানের তুলনায় ছোট কিনা তা পরীক্ষা করে [1,2,3,...]। যেহেতু কোন সদৃশ কোনো অনুপস্থিত বালতি বা আউট-অফ-অর্ডার হয় বালতি চেয়ে একটি মান বৃহত্তর কারণ হবে kk'ম স্থান, উপার্জন ফলে তালিকা বড় হতে ..


4

পাইথ, 6 বাইট

UItMsS

এখানে চেষ্টা করুন।

ব্যাখ্যা:

UItMsSQ
UI      Invariant from U (range(len(A)) for our purpose)
  tM     Map t (A - 1 for our purpose)
    s     s (flatten 1-deep for our purpose)
     S     S (sort for our purpose)
      Q     Q (autoinitialized to input) (implicit)

ওয়াত ?! UIঅংশে একটি ব্যাখ্যা যুক্ত করুন , দয়া করে
মিস্টার এক্সকোডার 4'17

@ Mr.Xcoder U <col>হয় range(len(A)), I <pfn> <any> <n-1:any>হয় A(B, ...) == B
এরিক দ্য আউটগল্ফার

তারপরে আমি মারাত্মকভাবে ছড়িয়ে পড়ে> <। যদিও আমি গল্ফ আমার। জিনিয়াস, উজ্জ্বল সমাধান, এখন দেখছি এটি কীভাবে কাজ করে ... অভিনন্দন!
মিঃ এক্সকোডার

@ মিঃ এক্সকোডার এটি সত্যই কেবল স্টাফগুলির জন্য ডক্স অনুসন্ধান করছে ...
এরিক দি আউটগল্ফার

না এইটা না. আমি জানতাম যে U <col>এটি range(len(A)), তবে আমি বুঝতে পারি নি যে পাইথন সমাধানটি পোর্ট করা আরও কম হবে ...
মিঃ এক্সকডার

4

PROLOG (SWI), 54 বাইট

s(L):-sort(L,M),flatten(M,N),last(N,O),numlist(1,O,N).

এখন যে আরও ভাল। এখনও বেশ ভার্জোজ, হায়।

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

দ্য s/1সম্পৃক্ত আর্গুমেন্ট হিসাবে একটি তালিকা নেয় এবং যদি তালিকা সহজে পারে.তবে বাকেট একটি তালিকা রয়েছে সত্য।

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

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

যদি এর সমস্ত ধারাটি সত্য হয় তবে ভবিষ্যদ্বাণীটি সত্য:

s(L) :-
    sort(L,M),                % M is L sorted in ascending order
    flatten(M,N),             % N is the 1-dimention version of M
    last(N,O),                % O is the last elemnt of N
    numlist(1,O,N).           % N is the list of all integers from 1 to O

পূর্ববর্তী উত্তর, PROLOG (SWI), 109 বাইট by

s(L):-flatten(L,M),sort(M,N),last(N,O),numlist(1,O,N),forall(member(A,L),(A=[B|_],last(A,C),numlist(B,C,A))).

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


3

পাইথ , 9 16 11 বাইট (স্থির)

অন্য উত্তর থেকে সম্পূর্ণ ভিন্ন পদ্ধতি ব্যবহার করে। একটি সংক্ষিপ্ত, 7-বাইট পদ্ধতির নীচে পাওয়া যাবে।

!.EtM.++0sS

পরীক্ষা স্যুট.


ব্যাখ্যা

! .এটিএম। ++ 0 এসকিউ -> সম্পূর্ণ প্রোগ্রাম, শেষে অন্তর্ভুক্ত ইনপুট সহ।

          এসকিউ -> প্রতিটি উপলিস্টে সর্বোচ্চ উপাদান দ্বারা ইনপুটটি বাছাই করুন।
         s -> সমতল।
       +0 -> একটি 0 প্রস্তুত করুন।
     । + -> তালিকার বদ্বীপগুলি পান (যেমন ধারাবাহিক উপাদানের মধ্যে পার্থক্য)
   tM -> প্রতিটি উপাদান হ্রাস।
 .E -> কোনও সত্যবাদী উপাদান (1 টি সত্যবাদী, 0 সেগুলি মিথ্যা)
! -> নেগেট (সুসংগত সত্য / মিথ্যা মান আছে)

কিভাবে কাজ করে?

আসুন কয়েকটি দৃষ্টান্ত নেওয়া যাক যা বোঝার পক্ষে সহজ করে তোলে। ধরা যাক ইনপুটটি হ'ল [[1,3,4],[5,7],[2,6]]। এই অ্যালগরিদমের মূলটি হ'ল বালতিগুলি স্ট্যাকেবল হওয়ার জন্য অবিচ্ছিন্ন তালিকার প্রতিটি ব-দ্বীপ অবশ্যই 1 হতে হবে।

  • প্রথম বন্ধ, Sএটি পরিণত [[1, 3, 4], [2, 6], [5, 7]]

  • তারপর, sএটা চ্যাপ্টা: [1, 3, 4, 2, 6, 5, 7]

  • 0সামনে একটি প্রস্তুত করুন :[0, 1, 3, 4, 2, 6, 5, 7]

  • .+তালিকার ডেল্টা পেয়েছে [1, 2, 1, -2, 4, -1, 2],।

  • tMপ্রতিটি উপাদান হ্রাস [0, 1, 0, -3, 3, -2, 1],।

  • 0পাইথের কোনও অ- পূর্ণসংখ্যার সত্যবাদী, সুতরাং আমরা সত্যতাযুক্ত কোনও উপাদান রয়েছে কিনা তা পরীক্ষা করে দেখি .E(যার অর্থ স্ট্যাকটি সঠিকভাবে গঠন করা যায় না)। আমরা পেতে True

  • !ফলাফল অবহেলা, যা পরিণত Trueহয় False

যদি ইনপুটটি ছিল, উদাহরণস্বরূপ, [[6,7,8,9,10],[1],[2],[3,4,5],[11,12,13]]অ্যালগরিদম এইভাবে কাজ করবে:

  • সর্বোচ্চ উপাদান অনুযায়ী সাজানো: [[1], [2], [3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13]]এবং সঙ্গে, চ্যাপ্টা 0prepended: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

  • Deltas: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]। সকল পেতে decremented: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

  • সত্যবাদী উপাদান নেই, তাই আমরা পেয়েছি False। যৌক্তিক অবহেলা দ্বারা, ফলাফল True


পাইথ , 7 বাইট

qSlsQsS

পরীক্ষা স্যুট.

পাইথন উত্তরের বন্দর এবং @ এরিকের সমাধানের বিভিন্নতা ।


এটি কীভাবে কাজ করে তা বোঝাতে সময় দেওয়ার জন্য আপনাকে অনেক ধন্যবাদ!
চার্লি


@ মিঃ এক্সকোডার tMপ্রতিটি উপাদানকে হ্রাস করে বলতে কী বোঝ ? আমি ভাবব যে প্রতিটি উপাদান হ্রাস [1, 2, 1, -2, 4, -1, 2]করলে ফলন হবে [0, 1, 0, -3, 3, -2, 1]। তবে এটি সমস্যা সমাধানে সহায়তা করবে না, সুতরাং প্রতিটি উপাদানকে হ্রাস করার অর্থ কী তা বোঝাতে হবে আমাকে।
ব্রায়ান জে

@ ব্রায়ানজে tMতালিকার প্রতিটি উপাদান কমিয়েছে 1। আমার ব্যাখ্যাতে একটি ভুল আছে। ঠিক করবে.
মিঃ এক্সকোডার

@ ব্রায়ানজে ফিক্সড এটি চিহ্নিত করার জন্য ধন্যবাদ
মিঃ এক্সকোডার

3

ব্র্যাচল্যাগ , 5 বাইট

oc~⟦₁

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

বর্ণিত আনফিকেশন:

?o₀c₀~⟦₁.
?         The input (implicit)
 o₀       Sorted (subscript default = 0 => ascending)
   c₀     Concatenated (subscript default = 0 => no length check)
     ~    Inverse (find the input)
      ⟦₁   Range (subscript = 1 => [1..input])
        . The output (implicit)

বিশ্লেষণাত্মক ব্যাখ্যা:

প্রথমে আমরা তালিকাগুলির তালিকাটিকে বাছাই করি এবং তারপরে আমরা সংক্ষিপ্তকরণ (অর্থাত্ 1-গভীর সমতল) ( oc) যাতে সম্ভব হয় যদি বালতিগুলি ডান থেকে বামে স্ট্যাক করা হয়। তারপরে, বালতিগুলি সঠিকভাবে স্ট্যাক করা হয়েছে কিনা তা পরীক্ষা করতে (যেমন অনুপস্থিত বালতি বা টাওয়ার নেই), আমরা পরীক্ষা করে দেখি যে ফলাফলের তালিকাটি 1 থেকে এর দৈর্ঘ্য পর্যন্ত অন্তর্ভুক্তিক পরিসীমা। এখন, এর দৈর্ঘ্যের [1..n] ব্যাপ্তি ( {l⟦₁?}) এর সাথে তালিকার সমান-পরীক্ষার পরিবর্তে , আমরা কোনও ফাংশনটিতে একটি ইনপুট সন্ধান করার চেষ্টা করব যা যদি এমন একটি ব্যাপ্তি তৈরি করে ( ~⟦₁) থাকে তবে। যদি কোনও ইনপুট পাওয়া যায়, তবে প্রোগ্রামটি কোনও সমস্যা ছাড়াই শেষ হয়, সুতরাং এটি একটি true.স্ট্যাটাসটিকে ট্রিগার করে । যদি কোনও ইনপুট পাওয়া যায় না, তবে একটি false.স্থিতি ট্রিগার করে প্রোগ্রামটি ব্যর্থ হয় ।


3

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

lambda l:sum(sorted(l),[0])<range(len(`l`))

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

সংক্ষিপ্ত আকারে বাছাই করা তালিকা [1,2,3,...N]বৃহত্তর তুলনায় অভিধানিকভাবে ছোট কিনা তা পরীক্ষা করে N। যেহেতু কোন সদৃশ কোনো অনুপস্থিত বালতি বা আউট-অফ-অর্ডার হয় বালতি চেয়ে একটি মান বৃহত্তর কারণ হবে kk'ম স্থান, উপার্জন ফলে তালিকা বড় হতে। ইনপুটটির স্ট্রিং-দৈর্ঘ্য উপরের বাউন্ড হিসাবে যথেষ্ট কারণ প্রতিটি সংখ্যা 1 টির বেশি অক্ষর নেয়।


ভাল লাগল, আমি ভেবেছিলাম আমার সমাধানে যথেষ্ট উন্নতির একটি উপায় থাকা উচিত এবং এটি এটি!
ক্রিস_আরেন্ডস

3

এমএটিএল , 5 বাইট

Sgtf=

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

(অন্তর্নিহিত ইনপুট, বলুন {[4,5],[9,10],[1,2,3],[6,7,8]} )

S - ইনপুট অ্যারেগুলি অভিধানিক ক্রমে সাজান ({[1,2,3],[4,5],[6,7,8],[9,10]} )

g - একটি একক অ্যারে রূপান্তর (cell2mat )

t - এটি সদৃশ

f- শূন্য-অমূল্যের সূচকগুলি সন্ধান করুন। যেহেতু ইনপুট এখানে সমস্ত জিরো নয়, সূচকের তালিকাটি 1 থেকে দৈর্ঘ্যে (অ্যারে) ফেরত দেয় ([1,2,3,4,5,6,7,8,9,10],[1,2,3,4,5,6,7,8,9,10] )

= - অ্যারে 1 থেকে দৈর্ঘ্যের (অ্যারে) এর সমান কিনা তা পরীক্ষা করুন


3

জাপট , ১৩ 12 11 বাইট

এটি সম্ভবত সংক্ষিপ্ত হতে পারে।

ñÎc äaT e¥1
  • 1 বাইট ETH ধন্যবাদ সংরক্ষণ করা

চেষ্টা করে দেখুন বা সমস্ত পরীক্ষার কেস চালান


ব্যাখ্যা

                :Implicit input of 2D array `U`
ñÎ              :Sort sub-arrays by their first element
  c             :Flatten
      T         :Prepend 0
    äa          :Consecutive absolute differences
        e¥1     :Does every element equal 1?

হ্যাঁ, আপনি ঠিক বলেছেন আমি মনে করি। যদিও এটি শট করার উপযুক্ত ছিল
ইটিএইচ প্রডাকশনগুলি

আমি মনে করি আপনি ä-0 e¥Jবা এর সাথে শেষ লাইনে একটি বাইট সংরক্ষণ করতে পারেনän0 e¥1
ইটিএইচ প্রডাকশনগুলি

আর একটি অনুরূপ 13 বাইট সমাধান: ethproductions.github.io/japt/…
অলিভার

@ ইথ প্রডাকশনস, সেখানে কী ঘটছে আমার কোনও ধারণা নেই! : ডি ভাবেন না যে আমি äএখনও অ্যারেগুলির জন্য স্পর্শ করার সুযোগ পেয়েছি । সংরক্ষণের জন্য ধন্যবাদ।
শেগি

1
@ লুইসফেলিপডেজেসাস মুনোজ আপনি যখন এই সমাধানটির প্রথম লাইন এবং সংযুক্ত সমাধানের দ্বিতীয় লাইনটি ব্যবহার করবেন তখন এটি কাজ করে, যেমনটি আমি বলেছিলাম, নাইট
নিট

2

স্কালা, 49 বাইট

p=>{val s=p.sortBy(_(0)).flatten
s==(1 to s.max)}

Ungolfed:

piles: List[List[Int]] =>
{
  val sorted = piles.sortBy(pile=>pile(0)).flatten //Since piles are sequential, we can sort them by their first element
  sorted == (1 to sorted.max) //If all the buckets are present and in order, after sorting them it should be equivalent to counting up from 1 to the max bucket
}


2

আর , 58 বাইট

function(v,a=unlist(v[order(sapply(v,min))]))any(a-seq(a))

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

নোট: মিথ্যা সত্যের ফলাফল, সত্য মিথ্যা

  • -3 বাইটস @ জাইসি ধন্যবাদ

ব্যাখ্যা:

a=unlist(v[order(sapply(v,min))])  # order the list of vector by the min value and flatten
all(a==seq(a=a))                   # if the flattened list is equal to 1:length then it's ok

1
কেবল seq(a)2 বাইটের জন্য ?. এছাড়াও, এটি TRUEএকটি মিথ্যা মান এবং তদ্বিপরীত হিসাবে ব্যবহার করার অনুমতি দেওয়া হয়েছে (কেবল আপনার উত্তরে নির্দিষ্ট করুন), যাতে আপনি any(a-seq(a))অন্য বাইট ব্যবহার করতে পারেন ।
জয়সি

@ জাসি: আমি একজন বোকা ... আমি seq(a)যখন aদৈর্ঘ্য 1 এর পরে অন্যরকম আচরণ করার বিষয়ে এতটা উদ্বিগ্ন ছিলাম এবং আমি মিস করেছি যে এক্ষেত্রে আমরা একই ফল পাব: ডি ধন্যবাদ!
ডিগইমল সমস্ত

1

সি # (.নেট কোর) , 157 145 132 বাইট

-13 বাইটস TheLethalCoder ধন্যবাদ

l=>{var k=l.OrderBy(x=>x[0]).SelectMany(x=>x);return!Enumerable.Range(1,k.Count()).Zip(k,(x,y)=>x==y).Any(x=>!x);}

বাইট গণনা অন্তর্ভুক্ত

using System.Linq;

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

Ungolfed:

l => {
        var k = l.OrderBy(x=>x[0])              // First, sort stacks by first bucket
                 .SelectMany(x => x);           // Concatenate stacks into one
        return !Enumerable.Range(1, k.Count())  // Create a sequence [1...n]
               .Zip(k, (x, y) => x == y)        // Check if our big stack corresponds the sequence
               .Any(x => !x);                   // Return if there were any differences
     };

1
x.First()-> x[0]? Enumerable.Range-> new int[]এবং Zipযদি সম্ভব হয় সূচক সহ ..? Whereশর্তটি সরিয়ে ফেলুন Any
TheLethalCoder

@TheLethalCoder টিপস জন্য আপনাকে ধন্যবাদ! এবং new int[]পদ্ধতির Select()জন্য সূচকটি পেতে একটি যুক্ত করা প্রয়োজন এবং শেষ পর্যন্ত বাইট সংখ্যাটি আরও বড় করে তুলবে।
গ্রেজগোর্জ পুয়াওস্কি


1

কাঠকয়লা , 19 বাইট (প্রতিযোগী নয়?)

A▷m⟦▷s▷vθυ⟧θ⁼θ…·¹Lθ

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

-10 বাইটস কেবলমাত্র ASCII- এর জন্য ধন্যবাদ ।

-3 বাইটস কেবলমাত্র এসসিআইআই-কে ধন্যবাদ পরবর্তী প্রয়োগের জন্য (সম্ভবত প্রতিযোগিতামূলক সংস্করণের জন্য সংশোধন ইতিহাস দেখুন)।

-সত্যবাদী, মিথ্যাচারের জন্য

চারকোল কীভাবে ইনপুট নেয় সেজন্য ইনপুট হল তালিকার তালিকার একটি সিঙ্গলটন তালিকা।


চারকোলের এটি প্রথম উত্তর যা আমি দেখতে পাই এটি ব্যবহার করে UP
চার্লি

@ কার্লোস আলেজো আমাকে বাছাইয়ের একটি উপায় খুঁজে পেতে হয়েছিল এবং সবচেয়ে সহজ উপায় ছিল সহজ UPsorted
এরিক আউটগল্ফার


সেখানে ব্যবহৃত স্কোপ জিনিসগুলিকে অগ্রাধিকার দেয় যদিও UPএটি এখনও কেন আছে তবে আমি অনুমান করি যে আপনি কেবল পাইথন ফাংশনটির নাম বর্ণ হিসাবে ব্যবহার করা এড়াতে পারবেন?
ASCII- কেবল

ইয়ে হিসাবে যোগ করা হয়েছে v , এও , ও_ও এটি কোনও অসি শিল্প চ্যালেঞ্জ নয় (অবাক হওয়ার কিছু নেই যে এটি এতটা অসম্পূর্ণ: P
ASCII- কেবল

0

জাভা 10, 213 বাইট

import java.util.*;m->{Arrays.sort(m,(a,b)->Long.compare(a[0],b[0]));var r=Arrays.stream(m).flatMapToInt(Arrays::stream).toArray();return Arrays.equals(r,java.util.stream.IntStream.range(1,r.length+1).toArray());}

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

আমি শুরু করার সময় এটি একটি ভাল ধারণা বলে মনে হয়েছিল, তবে এই বিল্টিনগুলি কেবল এটি দীর্ঘ করে দেয় .. অবশ্যই আরও ম্যানুয়াল পদ্ধতির সাহায্যে গল্ফ করা যেতে পারে ..

@ এরিকথিউটগলফারের 4 বাইট 05 এবি 1 ই উত্তর দ্বারা অনুপ্রাণিত । 4 বনাম 213 বাইট, rofl ..>।>

ব্যাখ্যা:

import java.util.*;      // Required import for Arrays
m->{                     // Method with 2D integer-array parameter and boolean return-type
  Arrays.sort(m,         //  Sort the 2D input-array on:
    (a,b)->Long.compare(a[0],b[0])); 
                         //  The first values of the inner arrays
var r=Arrays.stream(m).flatMapToInt(Arrays::stream).toArray();
                         //  Flatten the 2D array to a single integer-array
return Arrays.equals(r,  //  Check if this integer-array is equal to:
  java.util.stream.IntStream.range(1,r.length+1).toArray());} 
                         //  An integer-array of the range [1, length+1]
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.