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

ในอีกแง่หนึ่ง: รับรายการจำนวนเต็มบวก[a ₁ a ₂ … a _n ]ออกว่า

　　　　　　　gcd (a ₁ , a ₂ )> 1 && gcd (a ₂ , a ₃ )> 1 && … && gcd (a _{n − 1} , a _n )> 1

รายการจะมีองค์ประกอบอย่างน้อยสององค์ประกอบเสมอ (n ≥ 2)

อย่างไรก็ตาม ...

ความท้าทายนี้ยังมีการจำกัด แหล่งที่มา : โคเดอพ้อยท์ในคำตอบของคุณ

ตัวอย่างเช่นprint 2เป็นโปรแกรมที่ถูกต้อง ในฐานะที่เป็นรายการของ Unicode codepoints มันคือ[112 114 105 110 116 32 50]ซึ่งเป็นไปตามเงื่อนไขนี้: 112และ114แบ่งปันปัจจัยที่2 ; และ114และ105แบ่งปันปัจจัย3ฯลฯ

อย่างไรก็ตามไม่mainสามารถเกิดขึ้นได้ในโปรแกรมที่ถูกต้อง (ขออภัย!) ในขณะที่ Unicode codepoints ของmและaคือ109และ97เป็น coprime (โชคดีที่การส่งของคุณไม่จำเป็นต้องเป็นโปรแกรมเต็มรูปแบบ!)

โปรแกรมของคุณไม่ได้รับอนุญาตให้มี codepoint 0

กรณีทดสอบ

Truthy:

[6 21] -> 1
[502 230 524 618 996] -> 1
[314 112 938 792 309] -> 1
[666 642 658 642 849 675 910 328 320] -> 1
[922 614 530 660 438 854 861 357 477] -> 1

Falsy:

[6 7] -> 0
[629 474 502 133 138] -> 0
[420 679 719 475 624] -> 0
[515 850 726 324 764 555 752 888 467] -> 0
[946 423 427 507 899 812 786 576 844] -> 0

นี่คือcode-golf : รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

MATL , 14 ไบต์

!TM1*Zdl2$Xdl-

เอาต์พุตนี้เป็นเวกเตอร์คอลัมน์ที่ไม่ว่างเปล่าของจำนวนที่ไม่ใช่ศูนย์เป็นความจริงหรือเวกเตอร์ที่มีรายการศูนย์เป็นอย่างน้อยเป็นเท็จ

• ลองออนไลน์!

• ตรวจสอบกรณีทดสอบทั้งหมด รหัสส่วนท้ายมีifสาขาเพื่อทดสอบความจริง / ความผิดพลาด

• เนื่องจาก MATL ใช้ ASCII ซอร์สโค้ดจึงถูกเข้ารหัสเป็น

  [33 84 77 49 42 90 100 108 50 36 88 100 108 45]
  

  ซึ่งตอบสนองความต้องการ

คำอธิบาย

!     % Implicit input. Transpose
TM    % Push input to latest function again
1*    % Multiply by 1 (does nothing, but matches factors)
Zd    % Compute gcd with broadcast: matrix of gcd of all pairs
l     % Push 1
2$    % The next function will use 2 inputs
Xd    % Extract diagonal 1 (i.e. that below the main diagonal) from the matrix
l-    % Subtract 1 from each entry. Implicitly display

Haskell , 103 100 ไบต์

แก้ไข:

• -3 ไบต์: ใช้ตัวd<-fzป้องกันเพื่อผสานและย่อสองบรรทัดสุดท้าย

fBoolเป็นหน้าที่หลักซึ่งจะนำรายชื่อของจำนวนเต็มและผลตอบแทนที่

โปรดทราบว่าสองคนแรกԁ(เท่านั้น) คืออักขระ Cyrillic (Komi) Unicode และมีอักขระแท็บก่อนหน้าอักขระแรก

f	ԁ=zb[ԁ]id
zb[h:p:l]fz=z h p&&zb[p:l]fz
zb l fz=z 0 2
z 0z=z>z^0
z f fz|f<fz=z fz f|d<-fz=z d$f-d

ลองออนไลน์! หรือทดสอบด้วยตัวเอง

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

• fเป็นหน้าที่หลัก สิ่งที่มันทำคือห่ออาร์กิวเมนต์ԁในรายการซิงเกิลตัน (เนื่องจากค่า ASCII หลักของ)วงเล็บทำให้น่าอึดอัดใจมากกว่าการใช้วงเล็บเหลี่ยม) และเรียกใช้zbด้วยและอาร์กิวเมนต์ดัมมี่ (ฟังก์ชัน Haskell idมีเพียงอักขระที่เหมาะสมเพื่อให้พอดี ที่นี่)
  • การเดินทางของตัวละครเดียวกันเพื่อให้พอดีนอกจากนี้ทั้งสอง=]เป็นไปไม่ได้กับ ASCII ธรรมดาดังนั้นอาร์กิวเมนต์เป็นชื่อที่มี 2 ไบต์อักขระ Unicode CYRILLIC SMALL LETTER KOMI DE (ԁ)ค่า codepoint ซึ่งเหมาะกับทุกคนและ 3*7*61=U+0501[
    • เนื่องจาก codepoint ไม่ได้เป็น (ตัวเลือกที่เล็กที่สุดที่เป็นตัวระบุทางกฎหมายและยังใช้สามไบต์) สิ่งนี้จำเป็นต้องใช้อักขระแท็บแทนการเว้นวรรคก่อน
    • ตัวเลือก ASCII f fz|bf<-fz=zb[bf]fzธรรมดาเจ็ดไบต์อีกต่อไปคือการเปลี่ยนชื่ออาร์กิวเมนต์:
• zbเวลาสองขัดแย้งรายการเดี่ยวที่มีองค์ประกอบเป็นรายการที่แท้จริงของตัวเลขถูก recursed บนและอาร์กิวเมนต์หุ่นfzจำเป็นเท่านั้นที่จะได้รับzก่อนที่จะฟังก์ชั่นของ=s
  • เมื่อรายการภายในมีอย่างน้อยสององค์ประกอบฟังก์ชั่นzเรียกว่ามีสองคนแรก (ชื่อhและp) และหากผลตอบแทนที่True, zbrecurses หางp:lของรายการ
  • ถ้ารายการภายในมีน้อยกว่าสององค์ประกอบผลตอบแทนzb Trueเนื่องจาก=ความต้องการที่จะตามมาด้วยอักขระzวิธีที่ง่ายที่สุดในการทำเช่นนี้คือการใช้การเรียกร้องของที่ฟังก์ชั่นที่ตัวเองเป็นที่รู้จักกันกลับมาzTrue
• zใช้เวลาสองข้อโต้แย้งและคำนวณตัวหารร่วมที่ยิ่งใหญ่ที่สุดของพวกเขาซ้ำโดยใช้การลบ (การหารจำนวนเต็มอื่น ๆ ที่เกี่ยวข้องหรือฟังก์ชั่น gcd ไม่สามารถใช้งานได้) กลับมาTrueถ้ามันมากกว่าหนึ่ง
  • การเรียกซ้ำจะสิ้นสุดลงเมื่ออาร์กิวเมนต์แรกคืออาร์กิวเมนต์0ที่สองคือ gcd ในบรรทัดนี้อาร์กิวเมนต์ที่สองนั้นมีชื่อzเช่นกัน ตัวละคร1นั้นน่าอึดอัดใจที่นี่ดังนั้นจึงz^0ถูกใช้เพื่อให้ได้อันดับหนึ่ง
  • มิฉะนั้นถ้าอาร์กิวเมนต์แรกfมีขนาดเล็กกว่าสองอาร์กิวเมนต์จะfzถูกสลับและเรียกzซ้ำ
  • มิฉะนั้นอาร์กิวเมนต์ที่มีขนาดเล็กจะถูกหักออกจากค่าที่มีขนาดใหญ่กว่านั้นจะเรียกใช้zซ้ำอีกครั้ง (เช่นการแลกเปลี่ยนอาร์กิวเมนต์แม้ว่าจะเป็นการหลีกเลี่ยงวงเล็บ)

05AB1E , 8 ไบต์

รหัส

ü‚ÒüÃP≠P

ใช้การเข้ารหัส05AB1Eซึ่งให้รายการรหัสจุดต่อไปนี้แก่เรา:

hex: [0xFC, 0x82, 0xD2, 0xFC, 0xC3, 0x50, 0x16, 0x50]
dec: [252,  130,  210,  252,  195,  80,   22,   80]

ลองออนไลน์! หรือยืนยันซอร์สโค้ด!

คำอธิบาย

เนื่องจากโอเปอเรเตอร์ gcd ( ¿) มีจุดรหัสเฉพาะฉันจึงต้องหาวิธีอื่น ๆ ในการตรวจสอบการมีส่วนร่วม:

ü‚          # Get an array of adjacent pairs of the input
  Ò         # Factorize both elements of each pair in the array
   üà       # For each pair, get the intersection of both prime factorization lists
     P      # Product of each intersection (this leaves 1 when there is no intersection)
      ≠     # Check for each element whether it does not equal 1
       P    # Product of the booleans

Husk , 8 ไบต์

สำหรับอินพุต Truthy จะส่งคืนจำนวนเต็มบวกสำหรับ Falsy ที่คืนค่า 0

←▼`Ṡt(ż⌋

ลองออนไลน์! และทดสอบบน codepoints ของตัวเอง

ใช้เพจของ Husk

Source -- [ ←  , ▼  , `  , Ṡ  , t  , (  , ż  , ⌋  ]
Hex    -- [0x06,0xbd,0x60,0xd0,0x74,0x28,0xeb,0x8d]
Dec    -- [6   ,189 ,96  ,208 ,116 ,40  ,235 ,141]

คำอธิบาย

          -- implicit input, e.g                                  [63,36,18,3]
  `       -- flip the args of the next function
   Ṡ      -- some combinator (Ṡ f g x = f (g x) x)
    t     -- tail                                                 [36,18,3]
      ż   -- zipWith (note, keeps trailing elems of longer list)  [(63,36),(36,18),(18,3),(3)]
       ⌋  -- gcd                                                  [9,9,3,3]
     (    -- used just to match restricted source criteria
 ▼        -- minimum of the list                                    3
←         -- minus 1                                                2

Japt , 8 7 ไบต์

äj d¹¥Z

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

คะแนนรหัส:

Char    ä   j       d   ¹   ¥   Z
Hex    e4  6a  20  64  b9  a5  5a
Dec   228 106  32 100 185 165  90

คำอธิบาย

 äj d¹ ¥ Z
Uäj d) ==Z
             Implicit: U = input array, Z = 0
Uä           For each pair of items in the array:
  j            Return whether the two items are coprime.
    d)       Return true if any items are truthy, false otherwise.
       ==Z   Return whether this is equal to 0 (false -> true, true -> false).
             Implicit: output result of last expression

เยลลี่ , 11 9 ไบต์

,Pnælð2\P

ที่บันทึกไว้ 2 ไบต์ขอบคุณที่ @ โจนาธานอัลลัน

ลองออนไลน์!

เจลลี่มีหน้ารหัสของตัวเองและ codepoints ของตัวละครแต่ละตัวคือ

Chr Hex Dec
,   2c   44
P   50   80
n   6e  110
æ   16   22
l   6c  108
ð   18   24
2   32   50
\   5c   92
P   50   80

การทดสอบนี้สำหรับตัวเลขที่ไม่ใช่ coprime lcm(a, b) != a*bโดยตรวจสอบว่า อาจมีวิธีแก้ปัญหาที่สั้นกว่าเนื่องจากฉันเพิ่งกรองอักขระที่มีรหัสคู่

คำอธิบาย

,Pnælð2\P  Input: array A
      2\   For each overlapping sublist of size 2
     ð       Reduce it using this dyad
,              Pair
 P             Product
  n            Not equals, 1 if true else 0
   æl          LCM
        P  Product

TI-BASIC, 38 ไบต์

Input L1:ΔList(cumSum(L1:augment(Ans+V,V+{0:2>sum(AnsL1=lcm(Ans+V,V+L1

TI-พื้นฐานคือ tokenized เข้าไปในหนึ่งหรือสองไบต์ราชสกุลที่ระบุไว้ที่นี่

ส่วนที่ยากที่สุดของการแก้ปัญหานี้คือ:

1. เครื่องหมายจุลภาคเป็นจำนวนเฉพาะ (43) บังคับให้ฉันล้อมรอบด้วยทวีคูณของ 43 (ในกรณีนี้คือโทเค็น V ซึ่งคือ 86)

2. gcd (โทเค็นเป็นหมายเลขเฉพาะขนาดใหญ่ (47881) ซึ่งหมายความว่าไม่สามารถใช้งานได้เลย

โทเค็นสำหรับโปรแกรมนี้ออกมาที่:

token     hex     dec
Input     0xDC    220
L1        0x5D00  23808
:         0x3E    62
ΔList(    0xBB2C  47916
cumSum(   0xBB29  47913
L1        0x5D00  23808
:         0x3E    62
augment(  0x14    20
Ans       0x72    114
+         0x70    112
V         0x56    86
,         0x2B    43
V         0x56    86
+         0x70    112
{         0x08    8
0         0x30    48
:         0x3E    62
2         0x32    50
>         0x6C    106
sum(      0xB6    182
Ans       0x72    114
L1        0x5D00  23808
=         0x6A    106
lcm(      0xBB08  47880
Ans       0x72    114
+         0x70    112
V         0x56    86
,         0x2B    43
V         0x56    86
+         0x70    112
L1        0x5D00  23808

คำอธิบาย

Input L1:                   Prompt the user to input L1.

ΔList(cumSum(L1:            Take the differences of the prefix sum of L1,
                            which in effect removes the first element (result in Ans).

augment(Ans+V,V+{0:         Append a 0 to the end of Ans.
                            V defaults to 0, so adding it is a no-op.
                            Ans now holds L1 shifted to the left by one element,
                            with a 0 shifted in.

      AnsL1=lcm(Ans+V,V+L1  Take the least common multiple of each corresponding element
                            of Ans and L1, and check if each is equal to their product.
                            This returns a list of booleans, each 1 corresponding to
                            a co-prime pair. The last element (having been paired with 0)
                            will always be 1.

2>sum(                      Returns 1 if there is at most one 1 in the list, else 0.
                            Since the last element is always 1, this means
                            we return 1 only if there are no co-prime pairs.

Pyth , 15 ไบต์

&F.bPiFNP.TtBQQ

ลองที่นี่หรือตรวจสอบชุดทดสอบ

นี้เป็นความร่วมมือระหว่างเอริก Outgolferและนาย Xcoder ส่งคืนค่าที่ไม่สอดคล้องกัน (รายการที่ไม่ว่างเปล่า) สำหรับความจริงและรายการที่ว่างเปล่าสำหรับเท็จ

ASCII ค่า

[38, 70, 46, 98, 80, 105, 70, 78, 80, 46, 84, 116, 66, 81, 81]

ซึ่งแบ่งปันปัจจัยต่อไปนี้:

[2, 2, 2, 2, 5, 35, 2, 2, 2, 2, 4, 2, 3, 81]

คำอธิบาย

&F.bPiFNP.TtBQQ
           tBQ   Return [Q, Q[1:]] (Q = eval first line of input)
         .T      Transpose ^ without cropping absences
        P        Remove last element of ^
  .b          Q  Map in parallel on ^ (N) and Q (Y, ignored)
     iFN           GCD of N
    P              Prime factors of ^ (P(1) = [])
&F               Left fold (reduce) the result of the map with Logical AND (short-circuiting)

โดยไม่จำกัด เฉพาะแหล่งที่มาของความต้องการนี้จะได้รับเป็น7รุ่น 5 ไบต์บรรลุงานเดียวกัน (-2 ขอบคุณที่FryAmTheEggman ):

-1iVt

คำอธิบาย

-1iVtQQ  Implicit QQ at the end
    tQ   Return Q[1:]
  iV  Q  Vectorized GCD on ^ and Q
-1       Remove every element of ^ from [1] (implicit singleton)