เมื่อวานนี้ฉันถามคำถามนี้เกี่ยวกับ ruffle shuffles ดูเหมือนว่าคำถามเมื่อวานนี้ยากไปหน่อยดังนั้นคำถามนี้เป็นงานที่เกี่ยวข้อง แต่ง่ายกว่ามาก

วันนี้คุณจะถูกถามเพื่อตรวจสอบว่าการเปลี่ยนแปลงในความเป็นจริงสับเปลี่ยน riffle คำจำกัดความของการสลับแบบ riffle ของเราถูกดัดแปลงจากคำถามสุดท้ายของเรา:

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

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

การสลับแบบสุ่มแต่ละอันนั้นสามารถถูกมองว่าเป็นการเปลี่ยนแปลงไพ่สำรับดั้งเดิม ตัวอย่างเช่นการเปลี่ยนแปลง

1,2,3 -> 1,3,2

เป็นการสลับแบบ riffle ถ้าคุณแยกดาดฟ้าเช่นนั้น

1, 2 | 3

เราเห็นว่าการ์ดทุกใบใน1,3,2นั้นมีลำดับที่เหมือนกันกับการ์ดอื่น ๆ ในพาร์ติชั่น ยังคงเป็นหลังจากที่21

ในทางกลับกันการเรียงสับเปลี่ยนต่อไปนี้ไม่ใช่การสลับแบบ riffle

1,2,3 -> 3,2,1

เราสามารถเห็นสิ่งนี้ได้เพราะพาร์ติชั่นทั้งสอง (ไม่สำคัญ)

1, 2 | 3
1 | 2, 3 

มีคู่ของการ์ดที่ไม่รักษาลำดับญาติของพวกเขา ในพาร์ติชันแรก1และ2เปลี่ยนลำดับของพวกเขาในขณะที่พาร์ติชันที่สอง2และ3เปลี่ยนลำดับของพวกเขา

งาน

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

นี่คือcode-golfดังนั้นคำตอบจะได้คะแนนเป็นไบต์โดยไบต์น้อยจะดีขึ้น

กรณีทดสอบ

1,3,2 -> True
3,2,1 -> False
3,1,2,4 -> True
2,3,4,1 -> True
4,3,2,1 -> False
1,2,3,4,5 -> True
1,2,5,4,3 -> False
5,1,4,2,3 -> False
3,1,4,2,5 -> True
2,3,6,1,4,5 -> False

JavaScript (ES6), 47 ไบต์

รับอินพุตเป็นอาร์เรย์ของจำนวนเต็ม ส่งคืนบูลีน

([x,...a],y)=>a.every(z=>z+~x?y?z==++y:y=z:++x)

กรณีทดสอบ

let f =

([x,...a],y)=>a.every(z=>z+~x?y?z==++y:y=z:++x)

;[
  [1,3,2      ],  // -> True
  [3,2,1      ],  // -> False
  [3,1,2,4    ],  // -> True
  [2,3,4,1    ],  // -> True
  [4,3,2,1    ],  // -> False
  [1,2,3,4,5  ],  // -> True
  [1,2,5,4,3  ],  // -> False
  [3,1,4,2,5  ],  // -> True
  [2,3,6,1,4,5]   // -> False
]
.forEach(a => console.log(JSON.stringify(a) + ' -> ' + f(a)))

อย่างไร?

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

กฎความท้าทายที่ระบุว่าเรากำลังได้รับการเปลี่ยนแปลงของ[1 ... N] ดังนั้นเราไม่จำเป็นต้องตรวจสอบเพิ่มเติมว่าการเรียงลำดับของลำดับเหล่านี้จริง ๆ แล้วส่งผลให้มีช่วงดังกล่าว

เราใช้ตัวนับxเริ่มต้นเป็น A [0]และตัวนับyเริ่มไม่ได้กำหนดไว้

สำหรับแต่ละรายการzในAเริ่มต้นด้วยรายการที่สอง:

• เราตรวจสอบว่าZเท่ากับทั้งx + 1หรือY + 1 ถ้าใช่เราจะเพิ่มตัวนับที่สอดคล้องกัน
• อื่น ๆ : ถ้าปียังคงไม่ได้กำหนดเราเริ่มต้นมันจะZ
• อื่น: เราทำให้การทดสอบล้มเหลว

Haskell , 41 ไบต์

n%h=n+0^(n-h)^2
f l=elem(foldl(%)0$l++l)l

ลองออนไลน์!

ตรวจสอบว่ารายการที่ต่อกันกับตัวเองมีตัวเลข0..n-1ตามลำดับหรือไม่

Haskell , 43 ไบต์

sรับรายการของจำนวนเต็มเช่นในตัวอย่าง OP Boolและผลตอบแทน

s p=or[f(<x)p++f(>=x)p<[1..]|x<-p]
f=filter

ลองออนไลน์!

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

• ความเข้าใจในรายการจะพยายามแต่ละองค์ประกอบxของการpเปิดและตรวจสอบว่าสามารถเป็นองค์ประกอบแรกของพาร์ทิชันที่สองของการสับเปลี่ยน จากนั้นorจะส่งกลับถ้ามีการตรวจสอบได้TrueTrue
• ความเข้าใจทำสิ่งนี้โดยการแบ่ง (กับfilter) pลงในองค์ประกอบที่มีขนาดเล็กและใหญ่กว่า (หรือเท่ากับ) x, เรียงต่อกันและตรวจสอบว่ารายการผลลัพธ์คือ[1..length p]องค์ประกอบตามลำดับ
• การตรวจสอบว่า[1..length p]มีการทำรายการผลลัพธ์หรือไม่โดยดูว่าผลลัพธ์นั้นมีขนาดเล็กกว่ารายการที่ไม่มีที่สิ้นสุดอย่างเคร่งครัดหรือไม่[1..] == [1,2,3,etc.]ซึ่งจะให้ผลลัพธ์เดียวกันสำหรับการเปลี่ยนแปลงใด ๆ

เยลลี่ , 13 6 ไบต์

ỤIṢḊRẠ

ลองออนไลน์!

เวอร์ชันสำรอง postdates challenge, 5 ไบต์

Ụ>ƝSỊ

ลองออนไลน์!

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

ỤIṢḊRẠ  Main link. Argument: A (permutation of [1, ..., n])

Ụ       Grade up; sort the indices of A by their respective values.
        For shuffles, the result is the concatenation of up to two increasing
        sequences of indices.
 I      Compute the forward differences.
        In a shuffle, only one difference may be negative.
  Ṣ     Sort the differences.
   Ḋ    Dequeue; remove the first (smallest) difference.
    R   Range; map each k to [1, ..., k].
        This yields an empty array for non-positive values of k.
     Ạ  All; check if all resulting ranges are non-empty.

Python 2 , 39 ไบต์

l=input()
n=0
for x in l*2:n+=n==x
l[n]

ลองออนไลน์!

รับรายการที่จัดทำดัชนี 0 และส่งออกผ่านรหัสทางออก

Brachylogขนาด 9 ไบต์

o~cĊ⟨⊆⊇⟩?

ลองออนไลน์!

คำกริยาประสบความสำเร็จถ้าใส่หมายสับเป็นระลอกคลื่นน้อยและล้มเหลวถ้ามันไม่ได้มีความหมายในสิ่งอื่น ๆ ว่าถ้ากริยามีการเรียกใช้ในฐานะที่เป็นความสำเร็จของโปรแกรมทั้งหมดจะพิมพ์และความล้มเหลวจะพิมพ์true. false.อินพุตถูกใช้เป็นรายการของไอเท็มใด ๆ และตีความเป็นตัวแทนเรียงลำดับเรียงสับเปลี่ยนของตัวเอง

   Ċ         Some length-two list
 ~c          which concatenated
o            is the input sorted
    ⟨        satisfies the condition that its first element
     ⊆       is an ordered not-necessarily-contiguous sublist
        ?    of the input
      ⊇      which is an ordered superlist of
       ⟩     the list's second element.

ฉันรู้สึกเหมือนมีอะไรบางอย่างอยู่ในจิตวิญญาณของ⊆ᵐซึ่งควรจะทำงานในสถานที่ของสี่ไบต์ "แซนวิช" ⟨⊆⊇⟩สร้าง

Python 2 , 75 60 47 ไบต์

ขอบคุณเดนนิสสำหรับ -13 ไบต์

x={0}
for v in input():x=x-{v-1}|{v}
len(x)<3>q

ลองออนไลน์!

ผลลัพธ์คือรหัสทางออก

Ruby , 35 ไบต์

->l{l.any?{|a|l&[*1..a]|l==l.sort}}

ลองออนไลน์!

อย่างไร?

• l & [*1..a] | lใช้การแยกและจากนั้นสหภาพ: ก่อนรับองค์ประกอบlที่มี<=aแล้วเพิ่มองค์ประกอบที่เหลือของlโดยไม่เปลี่ยนลำดับ lถ้าเป็นจำนวนที่เรากำลังมองหาแล้วการดำเนินการนี้เป็นเช่นเดียวกับการเรียงลำดับ

ทำความสะอาด , 56 55 ไบต์

import StdEnv
?l=any(\e=sortBy(\a b=a<e&&b>=e)l<[1..])l

ลองออนไลน์!

Pyth, 5 ไบต์

}SQy+

ชุดทดสอบ

}SQy+

    +QQ  concatenated two copies of the (implicit) input
   y     all subsequences of it
}        contain an element equaling
 SQ      the input list sorted 

ตรวจสอบว่ารายการอินพุตสองเท่ามีเวอร์ชันที่เรียงลำดับของตัวเองเป็นลำดับหรือไม่

ขอขอบคุณที่เอริก Outgolfer 1 ไบต์การใช้ประโยชน์ที่ดีขึ้นของการป้อนข้อมูลโดยปริยายด้วยมากกว่า+QQ*2Q

Pyth , 9 ไบต์

!t-.+xLQS

ชุดทดสอบ

ที่บันทึกไว้ 3 ไบต์ขอบคุณที่isaacg

Pyth , 14 ไบต์

}SQm.nS.Tcd2./

ลองที่นี่! หรือตรวจสอบกรณีทดสอบทั้งหมด

เอาต์พุตTrueและFalseสำหรับ riffle-shuffle และ non-riffle-shuffle ตามลำดับ

อย่างไร?

} SQm.nS.Tcd2./ ~ โปรแกรมเต็ม อ่านอินพุตจาก STDIN และเอาต์พุตไปยัง STDOUT

            ./ ~ คืนค่าดิวิชั่นทั้งหมดของอินพุตให้เป็นสตริงย่อยแบบแยกส่วน (พาร์ติชัน)
   m ~ แผนที่เหนือด้านบนโดยใช้ตัวแปร d
         cd2 ~ สับลงในรายการสององค์ประกอบ
       .T ~ ชอบธรรมทรานสปอน
      S ~ เรียงลำดับ (พจนานุกรม)
    .n ~ แบนราบ
} ~ ตรวจสอบว่าข้างต้นมี ...
 SQ ~ อินพุตที่เรียงลำดับแล้ว

Husk , 7 ไบต์

±§#OoṖD

ชุดทดสอบ!

Perl, 28 ไบต์

รวม+1สำหรับa

ใส่ STDIN ตาม 1

perl -aE '$.+=$_==$.for@F,@F;say$.>@F' <<< "3 1 2 4"

ใช้อัลกอริทึมของ xnor

C (gcc) , 61 ไบต์

a,b,B;f(int*A){for(a=b=B=1;*A;A++)a-*A?B*=*A>b,b=*A:++a;b=B;}

ลองออนไลน์!