รายการที่ จำกัด ด้วยตนเอง

พิจารณารายการที่ไม่มีข้อ จำกัดLที่มีจำนวนเต็มที่ไม่ใช่ค่าลบ การทำงานในLเป็นรายการย่อยที่ต่อเนื่องกันขององค์ประกอบที่เท่ากันซึ่งไม่สามารถทำได้อีกต่อไป ตัวอย่างเช่นการวิ่งของ[0,0,1,1,3,3,3,2,1,1]คือ[0,0], [1,1], [3,3,3], [2 ], [1,1] รายการLเป็นตัว จำกัดถ้าแต่ละจำนวนเต็มN ≥ 1จำนวนของการเกิดขึ้นของNมีค่าน้อยกว่าหรือเท่ากับจำนวนของการทำงานของN-1 รายการด้านบนไม่ จำกัด ตัวเองเนื่องจากมีการเกิดขึ้น 4 ครั้งที่1แต่เรียกใช้เพียง0ครั้งเดียว

นี่คือตัวอย่างของรายการที่ตนเอง จำกัด นี้: [0,0,3,4,1,0,2,1,1,0,2,1,0,0,0,1,0] มันมี

• 5 การวิ่งของ0และ 5 การเกิดขึ้นของ1 ,
• 4 วิ่ง1และ 2 การเกิดขึ้นของ2 ,
• 2 การวิ่งของ2และ 1 การเกิดขึ้นของ3 ,
• 1 การทำงานของ3และ 1 เกิด4 ,
• 1 การทำงานของ4และการเกิดขึ้นของไม่มี5 ,
• ไม่มีการเกิดขึ้นของจำนวนเต็มอื่น ๆ

งาน

งานของคุณคือตัดสินใจว่ารายการนั้น จำกัด ตัวเองหรือไม่ อย่างชัดเจนยิ่งขึ้นอินพุตของคุณจะต้องเป็นรายการที่ไม่มีข้อ จำกัด ของจำนวนเต็มที่ไม่ต้องการลบ หากรายการมีการ จำกัด ตัวเองผลลัพธ์ของคุณจะเป็นจริง มิฉะนั้นจะเป็นเท็จ อินพุตและเอาต์พุตสามารถอยู่ในรูปแบบที่สมเหตุสมผล

จำนวนไบต์ต่ำสุดในแต่ละภาษาการเขียนโปรแกรมเป็นผู้ชนะ ใช้กฎมาตรฐานของกอล์ฟ

กรณีทดสอบ

อินสแตนซ์ที่แท้จริง:

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

อินสแตนซ์ที่เป็นเท็จ:

[2]
[1,1,0]
[0,0,1,1,1,0,0,2]
[0,1,0,1,1,2,2,3,0,0,4,6]
[1,1,2,1,2,0,2,0,3,0,0,2,2,1,2,3,2,0,1,1,1,0,0,3,3,0]
[3,4,1,0,0,0,5,5,0,2,2,0,0,0,0,0,2,0,1,1,0,4,3,5,4,3]
[1,0,0,0,2,5,3,1,1,0,3,3,1,3,5,4,0,4,0,0,2,0,2,1,1,5,0,0,2,4,4,0,2,0,1,4,4,2,3,3,5,3,4,0,2,0,5]
[4,3,1,0,0,4,6,6,1,0,1,2,1,3,0,1,0,2,0,3,4,0,2,1,1,3,0,2,2,2,0,5,5,0,5,2,5,5,0,4,3,2,3,1,1,3,5,1,4,1,6,2,6,2,4,0,4,0,4,5,3,3,0,0,6,1,0,0,0,6,2,1,0,1,2,6,2,4]
[5,1,1,1,0,2,0,6,1,0,2,1,2,2,5,3,1,0,0,0,3,2,3,0,1,1,0,1,0,1,1,2,0,6,4,1,2,1,1,6,4,1,2,2,4,0,1,2,2,1,3,0,1,2,0,0,0,2,0,2,2,0,1,0,0,1,3,0,0,0,6,2,0,1,0,1,2,1,1,1,0,4,0,0,5,2,0,0,0,4,1,2,2,2,2,0,5,3,2,4,5,0,5]

Perl 6 , 29 ไบต์

{bag(.grep(?*)X-1)⊆.squish}

ลองออนไลน์!

ความท้าทายที่ดีมากสำหรับ Perl 6 ใช้ตัวดำเนินการเซตย่อยบนกระเป๋า (ชุดจำนวนเต็ม) คำอธิบาย:

{
    bag(           # Create bag of
        .grep(?*)  # non-zero elements,
        X- 1       # decremented by one.
    )
    ⊆              # Subset test.
    .squish        # "squish" removes repeated elements in each run.
                   # The result is implicitly converted to a bag
                   # counting the number of runs.
}

JavaScript (ES6), 92 89 ไบต์

a=>a.map(n=>g(~n,n!=p&&g(p=n)),c=[j=0],p=g=n=>c[n]=-~c[n])&&!c.some((n,i)=>i-j++|n<c[~j])

ลองออนไลน์!

อย่างไร?

อาร์เรย์c []ใช้เพื่อเก็บทั้งจำนวนการรันและจำนวนการเกิดขึ้นของจำนวนเต็ม การรันจะถูกเก็บไว้ที่ดัชนีที่ไม่เป็นลบและเหตุการณ์จำนวนเต็มจะถูกเก็บไว้ที่ดัชนีของส่วนประกอบ 1 ( c [-1] = จำนวน0 's, c [-2] = จำนวน1 ' ฯลฯ

ดัชนีเชิงลบจะถูกบันทึกเป็นคุณสมบัติของวัตถุอาร์เรย์ต้นแบบ . some ()ไม่ได้ซ้ำกับพวกเขา

a =>                        // given the input array a[]
  a.map(n =>                // for each value n in a[]:
    g(                      //   update c[]:
      ~n,                   //     increment c[~n] (# of integer occurrences)
      n != p && g(p = n)    //     if n != p, set p to n and increment c[n] (# of runs)
    ),                      //   end of c[] update
    c = [j = 0],            //   start with c = [0] and j = 0 (used later)
    p =                     //   initialize p to a non-numeric value
    g = n => c[n] = -~c[n]  //   g = helper function to increment c[n]
  )                         // end of map()
  && !c.some((n, i) =>      // for each value n at position i in c[]:
    i - j++ |               //   make sure that i == j++
    n < c[~j]               //   and n is greater than or equal to c[~j]
  )                         // end of some()

Perl 5 -p , 49 48 44 ไบต์

#!/usr/bin/perl -p
$z[$_+1]+=!/^$o$/;$z[$o=$_]--}{$_="@z"!~/.-/

ลองออนไลน์!

เยลลี่ 10 ไบต์

œ-ŒgḢ€‘ƊS¬

ลองออนไลน์!

มันทำงานอย่างไร

œ-ŒgḢ€‘ƊS¬  Main link. Argument: A (array)

       Ɗ    Drei; group the three links to the left into a monadic chain.
  Œg          Group consecutive, identical elements of A into subarrays.
    Ḣ€        Head each; pop the first element of each run.
      ‘       Increment the extracted integers.
            The resulting array contains n repeated once for each run of (n-1)'s.
œ-          Perform multiset subtraction, removing one occurrence of n for each
            run of (n-1)'s.
       S    Take the sum. If only 0's remain, the sum will be 0.
        ¬   Take the logical NOT, mapping 0 to 1 and positive integers to 0.

เยลลี่ขนาด 19 ไบต์

ŒgḢ€ċЀṀḶ$<ċЀṀR$$Ẹ

ลองออนไลน์!

เยลลี่ขนาด 17 ไบต์

ŒgḢ€ċ’}<ċ
çЀx⁸ẸṆ

ลองออนไลน์!

Python 3 , 94 ไบต์

lambda a:all(sum(1for x,y in zip(a,a[1:]+[-1])if x==j!=y)>=a.count(j+1)for j in range(max(a)))

ลองออนไลน์!

Japt , 21 ไบต์

x o e@ó¥ mÌè¥X ¨Uè¥XÄ

ทดสอบออนไลน์!

Stax , 13 9 ไบต์

เดนนิสพบอัลกอริทึมที่ดีกว่ามาก ฉันย้ายพอร์ตไปที่สแตกซ์อย่างไร้ยางอาย

ä╨²@┬↕OR♣

เรียกใช้และแก้ไขข้อบกพร่องออนไลน์

คลายกล่อง ungolfed และแสดงความคิดเห็นนี่คือสิ่งที่ดูเหมือน

c   copy input
:g  get run elements
{^m increment each
|-  multiset-subtract from original input
|M! get maximum from result, and apply logical not

เรียกใช้อันนี้

คำตอบเก่า:

║Ä|╤#╫∩▼cëózü

เรียกใช้และแก้ไขข้อบกพร่อง

มันวนซ้ำอินพุตและตรวจสอบเงื่อนไข:

• เป็นองค์ประกอบ> 0หรือไม่
• คือoccurrences(element) >= runs(element - 1)อะไร

หากเงื่อนไขใดเงื่อนไขหนึ่งเหล่านี้เป็นจริงสำหรับองค์ประกอบแสดงว่าองค์ประกอบนั้นเป็นไปตามข้อกำหนด iff 1องค์ประกอบทั้งหมดเป็นไปตามผลที่ได้คือ

ต่อไปนี้เป็นการนำเสนอที่ยังไม่ได้แกะกล่อง ungolfed แสดงความคิดเห็นของโปรแกรมเดียวกัน

O           push 1 under the input
F           iterate over the input using the rest of program
  |c        skip this iteration of the value is 0
  x#        number of occurrences of this value in input (a)
  x:g _v#   number of runs of (current-1) in input (b)
  >!        not (a > b); this will be truthy iff this element is compliant
  *         multiply with running result

เรียกใช้อันนี้

Haskell, 80 ไบต์

import Data.List
o#l=[1|x<-l,x==o]
f x=and[(i-1)#(head<$>group x)>=i#x|i<-x,i>0]

ลองออนไลน์!