แนวคิดนี้มาจากBIO 2017 q1 เป็นหลัก ฉันมีความคิดในการโพสต์ความท้าทายนี้จากความท้าทายลำดับของฉันเนื่องจากผู้คนจำนวนมากดูเหมือนจะชอบมัน

นี่เป็นความท้าทายครั้งแรกที่ฉันโพสต์โดยไม่โพสต์บนกล่องทราย ฉันจะลบมันถ้าไม่มีใครชอบมัน

กฎระเบียบ

ใช้เวลาในลำดับของตัวเลขในแบบไตรภาค (ฐาน 3); สิ่งนี้อาจเป็นสตริงอาร์เรย์หรือค่าตัวเลขพร้อมกับจำนวนศูนย์ก่อนหน้า

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

0 0 1 2 0 1 2 2
 0 2 0 1 2 0 2
  1 1 2 0 1 1
   1 0 1 2 1
    2 2 0 0
     2 1 0
      0 2
       1

คุณคาดว่าจะคืนแถวสุดท้ายเท่านั้น

ทำให้รหัสของคุณสั้น

กรณีทดสอบ

0 -> 0
11 -> 1
10 -> 2
000 -> 0
012 -> 1
21102 -> 2
201021 -> 1
111111 -> 1
1020202020 -> 2
0212121210 -> 0

Husk , 9 ไบต์

%3←ΩεẊo_+

ลองออนไลน์!

คำอธิบาย

แนวคิดหลักคือการคำนวณการทำแผนที่ของทั้งสองตัวเลขไปทางหนึ่งเป็นf (A, B) = (-ab) 3% สำหรับวัตถุประสงค์ในการตีกอล์ฟเราสามารถหน่วงเวลาโมดูโล่ได้จนกว่าจะสิ้นสุด

   Ωε       Apply the following function until the list is only one
            element in length.
     Ẋo       Apply the following function to pairs of adjacent values.
       _+       Add the two values and negate the result.
  ←         Take the first (and only) element of this list.
%3          Take it modulo 3.

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

MATL 10 ไบต์

td"HYCEsI\

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

คำอธิบาย

สำหรับแต่ละคู่หลักรหัสจะคำนวณผลรวมโมดูโล่ 3 สองครั้งกระบวนการนี้ซ้ำหลายครั้งตามความยาวของอินพุตลบ 1

t        % Implicit input: array of length n. Duplicate
d        % Consecutive differences. Gives an array of length n-1
"        % For each (that is, do n-1 times)
  HYC    %   2-column matrix where each column is a sliding block of length 2
  E      %   Times 2, element-wise
  s      %   Sum of each column
  I\     %   Modulo 3
         % Implicit end. Implicit display

Python 2 , 48 ไบต์

f=lambda a,*l:-(f(*l)+f(a,*l[:-1]))%3if l else a

ลองออนไลน์!

เกิดขึ้นซ้ำในรายการย่อยการลบองค์ประกอบแรกและสุดท้ายตามลำดับ

นี้จะทำความสะอาดในหลาม 3 f=lambda a,*b,c:...ถ้ามันทำได้จริงแกะ

Emojicodeขนาด 242 ไบต์

🐋🍨🍇🐖🔢➡️🚂🍇🔂i⏩➖🐔🐕1 0🍇🔂j⏩0i🍇🍊❎😛🍺🔲🐽🐕j🚂🍺🔲🐽🐕➕1j🚂🍇🐷🐕j➖➖3🍺🔲🐽🐕j🚂🍺🔲🐽🐕➕1j🚂🍉🍉🍉🍎🍺🔲🐽🐕0🚂🍉🍉

ใช้อัลกอริทึมเดียวกันกับคำตอบ C ของฉัน ลองออนไลน์!

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

+2\N$Ḋ¿%3

ลองออนไลน์!

ใช้อัลกอริทึม Husk ของ Martin Ender

Haskell , 36 ไบต์

f[a]=a
f(h:t)=mod(-f t-f(h:init t))3

ลองออนไลน์!

บันทึก 1 ไบต์บนสมมาตรมากกว่านี้:

f[a]=a
f l=mod(-f(tail l)-f(init l))3

ลองออนไลน์!

แนวคิดนี้ง่าย: คำนวณฟังก์ชั่นซ้ำ ๆ ในรายการย่อยการลบองค์ประกอบแรกและองค์ประกอบสุดท้ายตามลำดับและรวมเข้าด้วย\a b -> mod(-a-b)3กัน ดูเหมือนว่าจะสั้นกว่าการใช้zipWithฟังก์ชั่นนี้

Haskell , 44 ไบต์

f[a]=mod a 3
f l=f$zipWith((-).(0-))l$tail l

ลองออนไลน์!

C (gcc) , 91 88 84 ไบต์

-1 ไบต์ต้องขอบคุณ @ Mr.Xcoder!

j;f(a,l)int*a;{for(;l-->1;)for(j=0;j<l;)a[j++]=a[j]^a[j+1]?3-a[j]-a[j+1]:a[j];a=*a;}

รับอาร์เรย์และความยาว ลองออนไลน์!

J, 23 15 ไบต์

3&(|2+/\-)~<:@#

ขอบคุณ @miles

โซลูชันเก่า:

3|2&(-@+/\)^:(#>1:)^:_]

แรงบันดาลใจจากโซลูชันของ Martin Ender:

คำอธิบาย

3|2&(-@+/\)^:(#>1:)^:_]    | Whole program
                      ]    | Seperates the argument from the _ (infinity)
           ^:(#>1:)^:_     | Do while the length is greater than one
  2&(-@+/\)                | Inverse of the sum of adjacent elements
3|                         | Modulo 3

แบตช์ 122 ไบต์

@set/an=2,s=i=l=0
@for %%e in (%*)do @set/al+=1,n^^=3
@for %%e in (%*)do @set/as+=%%e*n,s%%=3,n*=l-=1,n/=i+=1
@echo %s%

ใช้การขยายแบบทวินาม ตามที่ @MartinEnder ชี้ให้เห็นผลรวมจะต้องถูกทำให้เป็นโมฆะ (โมดูโล 3) หากจำนวนของค่า (ซึ่งนับในการวนซ้ำครั้งแรก) เป็นคู่ดังนั้นการnตั้งค่าเป็นอย่างใดอย่างหนึ่ง1หรือ2ตาม ลูปที่สองจะคำนวณผลรวมผ่านสัมประสิทธิ์ทวินาม

APL (Dyalog)ขนาด 17 ไบต์

{3|3-2+/⍵}⍣{1=≢⍺}

ลองออนไลน์!

อย่างไร?

2+/⍵ - รวมรายการที่อยู่ติดกันสองรายการ

3- - การลบเวกเตอร์จากสาม

3| - vectorized modulo โดยสาม

⍣ - ทำซ้ำจนกระทั่ง ...

1=≢⍺ - เหลือเพียงหนึ่งรายการ

APL + ชนะ30 28 ไบต์

2 ไบต์บันทึกความอนุเคราะห์ของ Uriel

n←⎕⋄¯1↑∊⍎¨(⍴n)⍴⊂'n←3|3-2+/n'

คำอธิบาย:

n←⎕ Prompt for screen input of the form: 0 0 1 2 0 1 2 2

'n←3|3-2+/n' Successive rows are 3 mod 3 minus successive digit pairs.

(⍴n)⍴⊂ Create a nested vector of the row code, one element per row. 

¯1↑∊⍎¨ Execute each element of row code, flatten result and take final value.

นี่เป็นวิธีหนึ่งในการเขียนโค้ดการวนซ้ำใน APL ในบรรทัดเดียว

Javascript (ES6), 58 ไบต์

f=s=>s[1]?f(s.replace(/.(?=(.?))/g,(a,b)=>b&&(6-a-b)%3)):s