ตัวเลขสุดท้ายจำนวนมาก


12

สำหรับรายการตัวเลขที่ระบุค้นหาตัวเลขสุดท้ายของ ตัวอย่าง:[x1,x2,x3,...,xn]x1x2x3xn

[3, 4, 2] == 1
[4, 3, 2] == 4
[4, 3, 1] == 4
[5, 3, 2] == 5   

เพราะ430467213(42)=316=43046721

เพราะ2621444(32)=49=262144

เพราะ644(31)=43=64

เพราะ19531255(32)=59=1953125

กฎ:

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่มีจำนวนไบต์น้อยที่สุดจะเป็นผู้ชนะ

หากภาษาของคุณมีข้อ จำกัด เกี่ยวกับขนาดจำนวนเต็ม (เช่น ) n จะมีขนาดเล็กพอที่ผลรวมจะพอดีกับจำนวนเต็ม2321

อินพุตอาจเป็นรูปแบบที่สมเหตุสมผล (stdin, ไฟล์, พารามิเตอร์บรรทัดคำสั่ง, จำนวนเต็ม, สตริง, ฯลฯ )

เอาต์พุตสามารถเป็นรูปแบบที่สมเหตุสมผลใด ๆ (stdout, ไฟล์, องค์ประกอบผู้ใช้แบบกราฟิกที่แสดงหมายเลข ฯลฯ )

เห็นในสงครามรหัส


2
ฉันมีคำถามหนึ่งข้อ: ในโพสต์ของคุณคุณพูดถึงnumberเท่านั้น คุณหมายถึงจำนวนเต็มบวกโดยเฉพาะหรือไม่ นั่นคือฉันรู้สึกว่ามันถูกตีความอย่างไร
Jonathan Frech

1
การป้อนข้อมูลในแบบย้อนกลับสมเหตุสมผลหรือไม่ อินพุตสามารถเป็นศูนย์ได้หรือไม่
NieDzejkob

1
ฉันคิดว่าคุณตั้งใจให้ขีด จำกัด นั้นอยู่ที่ผลรวมของคำศัพท์และกิจวัตรที่คำนวณผลรวมที่เกิดขึ้นจริงจากนั้น mod ควรจะล้มเหลว เช่นอินพุต[999999,213412499,34532599,4125159,53539,54256439,353259,4314319,5325329,1242149,142219,1243219,14149,1242149,124419,999999999]ถูกต้องและผลลัพธ์ควรเป็น1เช่นนั้นสิ่งนี้จะต้องทำให้ชัดเจนขึ้นในคำถามเมื่อคุณมีคำตอบ upvoted ที่ไม่ได้แก้ปัญหานี้ (hint - ย้ายmodภายในวง) อาจเพิ่มตัวอย่างที่ทำให้ชัดเจน
Neil Slater

1
9อันที่จริงผลจากตัวอย่างของฉันคือ รูปแบบการลดตัวเลขที่จำเป็นในการดำเนินการนี้น่าสนใจกว่าคำตอบที่แท้จริงที่ปัญหานี้ได้รวบรวมไว้
Neil Slater

2
เรียน OP เราต้องการกรณีทดสอบเพิ่มเติม
NieDzejkob

คำตอบ:


15

JavaScript (ES7), 22 ไบต์

จำกัด ให้22531

a=>eval(a.join`**`)%10

ลองออนไลน์!


2
ทำไมโลกนี้ถึงทำงาน
Caleb Jay

@ komali_2: **เป็นตัวดำเนินการการยกกำลังของ JavaScript ที่เหลือค่อนข้างตรงไปตรงมา
Shaggy

2
@ komali_2 a.join`**` เทียบเท่าa.join(['**'])และ['**']ถูกบังคับ'**'โดยjoinวิธีการ
Arnauld

1
ฉันคิดว่า OP ตั้งใจว่าขีด จำกัด อยู่ที่ผลรวมของค่าซึ่งในกรณีนี้ไม่สามารถแก้ปัญหาตามที่วางไว้
Neil Slater

1
@AJFaraday% 10 ในตอนท้าย เมื่อหารจำนวนใด ๆ ด้วย 10 ส่วนที่เหลือ (โมดูลัส) จะเป็นเลขหลักสุดท้ายเสมอดังนั้นn % 10จะส่งกลับตัวเลขหลักสุดท้ายของn
Skidsdev



9

HP 49G RPL, 36.5 ไบต์

เรียกใช้ในโหมดไปที่ (แต่ป้อนโปรแกรมในโหมด EXACT) ใช้อินพุตบนสแต็กที่มีอิลิเมนต์แรกที่ลึกที่สุดในสแต็กเป็นจำนวนเต็มหรือ reals

WHILE DEPTH 1 - REPEAT ^ END 10 MOD

ตรงไปตรงมาแทนเลขชี้กำลังในสแต็คเหมือนกับในโซลูชันของ Sophia จนกระทั่งเหลือค่าหนึ่งค่าจากนั้นใช้ mod 10 เพื่อรับตัวเลขสุดท้าย

เหตุผลที่ฉันใช้ไปเพื่อการคำนวณเป็นเพราะ 0.0 ^ 0.0 = 1 (เมื่อทั้งคู่ reals) แต่ 0 0 0 0 =? (เมื่อเป็นทั้งจำนวนเต็ม) ไปข้างหน้า coerces จำนวนเต็มทั้งหมดเพื่อ reals ดังนั้นการป้อนข้อมูลที่ดีกับทั้ง อย่างไรก็ตามฉันใช้ EXACT เพื่อเข้าสู่โปรแกรมเพราะ 10 (จำนวนเต็ม) ถูกเก็บไว้เป็นตัวเลขหลักและ 6.5 ไบต์ แต่ 10.0 (จริง) ถูกเก็บเป็นจำนวนจริงเต็มรูปแบบและ 10.5 ไบต์ ฉันยังหลีกเลี่ยงการใช้ RPL ของลด (เรียกว่า STREAM) เพราะมันแนะนำวัตถุโปรแกรมพิเศษซึ่งเป็น 10 ไบต์ของค่าใช้จ่าย ฉันมีแล้วและไม่ต้องการอีก

จำกัดความแม่นยำของ HP 49G จริง (ทศนิยม 12 หลัก)

-10 ไบต์หลังจากรายการว่าง -> ข้อกำหนด 1 รายการถูกลบแล้ว

-2 ไบต์โดยการป้อนข้อมูลในสแต็ก


1
สวัสดีคุณช่วยอธิบายวิธีคำนวณจำนวน bytecount ได้อย่างไร แค่อยากรู้ว่าภาษานั้นใช้ลูกเล่นอย่างไร
JungHwan Min

1
@JungHwanMin HP 49G ใช้ตัวประมวลผล 4 บิตและเลขคณิต BCD เนื่องจากเป็นเครื่องคิดเลข ภายในคำสั่งส่วนใหญ่จะถูกแปลงเป็น 2.5 พอยน์เตอร์พอยน์เตอร์ไปยังรูทีนที่แสดงเพื่อประหยัดพื้นที่ ตัวเลขขนาดเล็ก (0-9) จะถูกแปลงด้วยวิธีนี้
Jason

1
หน่วยประมวลผลของดาวเสาร์นั้นสนุกจริง ๆ ที่ได้ทำงานกับ ยาวเวลาที่ผ่านมาผมเขียนท่าเรือ BurgerTime นี้ (ในการชุมนุม) สำหรับ HP 48G (X) ต่อมาก็รังเพลิง 49G ความทรงจำที่ดี!
Arnauld

7

dc , 17 15 ไบต์

1[^z1<M]dsMxzA%

ลองออนไลน์!

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

ขอบคุณ brhfl สำหรับการบันทึกสองไบต์!


2
คุณสามารถเล่นกอล์ฟหนึ่งไบต์โดยเปลี่ยน10%เป็นA%และอีกหนึ่งไบต์โดยไม่ตรวจสอบความลึกของสแต็กสองครั้ง - เพียงวาง1บนสแต็กก่อนดำเนินการตั้งแต่ n ^ 1 == n:1[^z1<M]dsMxA%
brhfl

ความคิดที่ดี! ฉันไม่รู้ว่าจะให้ฉันใช้Aเป็นตัวอักษรในขณะที่ตั้งค่าให้ป้อนทศนิยม ขอบคุณ @brhfl!
Sophia Lechner

1
@SophiaLechner เคล็ดลับนี้ใช้ได้กับฐานอินพุตทั้งหมด: codegolf.stackexchange.com/a/77728/11259
Digital Trauma


6

05AB1E , 4 ไบต์

.«mθ

ลองออนไลน์!

คำอธิบาย

.«     # fold
  m    # power
   θ   # take the last digit

1
เท่าที่ฉันทราบภาษาที่อิงกับสแต็กสามารถสันนิษฐานว่าอินพุตมีอยู่ในสแต็กแทนที่จะเป็น STDIN หรือทางเลือกดังนั้นสิ่งนี้ควรทำงานได้ 4 ไบต์ (หรือเพียงแค่วางEในส่วนหัว)
Mr. Xcoder


1
ฉันได้แก้ไขปัญหานี้ในการส่งล่าสุดสำหรับใช้ในอนาคต
Adnan

@ Mr.Xcoder: ถูกต้อง! ฉันควรจะจำได้ว่า ดังนั้นไม่ค่อยจำเป็นต้องมีการป้อนข้อมูลโดยนัย ขอบคุณ :)
Emigna

@ Mr.Xcoder เอ่อฉันไม่แน่ใจว่านั่นคือสิ่งที่เมตาหมายถึงจริงๆ "ฟังก์ชั่น" ใน 05AB1E คืออะไร? ฉันคิดว่ามันควรเป็นเพียงสตริงเนื่องจากคุณสามารถกำหนดให้กับตัวแปรและสามารถใช้กับการ.Vวิเคราะห์ .«mθดูเหมือนข้อมูลโค้ดเนื่องจากด้วยตัวเองคุณไม่สามารถกำหนดให้กับตัวแปรเพื่อนำมาใช้ใหม่ในภายหลัง ตอนนี้ Adnan แก้ไขปัญหาได้แล้ว แต่เอ๊ะ
Erik the Outgolfer

5

Pure Bash (ในตัวเท่านั้น - ไม่มียูทิลิตี้ภายนอก), 21

echo $[${1//,/**}%10]

อินพุตถูกกำหนดบนบรรทัดรับคำสั่งเป็นรายการที่คั่นด้วยเครื่องหมายคอมมา

จำนวนเต็มทุบตีอยู่ภายใต้ข้อ จำกัด จำนวนเต็มที่ลงนามปกติสำหรับรุ่น 64- และ 32- บิต

ลองออนไลน์!


2
^เป็นแฮคเกอร์บิตซึ่งเป็นเหตุผลที่คุณได้รับจากกรณีทดสอบแทนการที่ถูกต้อง5 1คุณจะต้องเพิ่มไบต์เพื่อเปลี่ยนเป็น**
Sophia Lechner

@SophiaLechner ใช่ - แน่นอน - จับได้ดี! ไม่แน่ใจว่ามัน^พุ่งเข้ามา - ฉันเคย**ทำซ้ำรอบวัฏจักรของฉันมาก่อน
บาดเจ็บทางดิจิตอล



4

Ruby, 41 47 ไบต์

ขนาดเพิ่มขึ้นเนื่องจากการจัดการ 0 ใด ๆ ในอาร์เรย์อินพุตซึ่งจำเป็นต้องพิจารณาเป็นพิเศษ ขอบคุณที่rewritten

->a{a.reverse.inject{|t,n|n<2?n:n**(t%4+4)}%10}

สิ่งนี้ได้รับการแก้ไขเนื่องจากฉันเชื่อว่าต้นฉบับดั้งเดิมที่ตั้งใจไว้คือสำหรับ exponentiations ที่มีขนาดใหญ่มากซึ่งจะไม่พอดีกับจำนวนเต็มภาษาดั้งเดิมข้อ จำกัด คืออาร์เรย์จะรวมเข้า2**32-1ด้วยกันไม่ใช่ว่าการคำนวณระหว่างกาลนั้นจะรับประกันได้พอดี ในความเป็นจริงที่ดูเหมือนจะเป็นจุดท้าทายของ Code Wars แม้ว่าจำนวนเต็มพื้นฐานของรูบี้จะค่อนข้างใหญ่ แต่ก็ไม่สามารถรับมือกับตัวอย่างด้านล่างที่ประมวลผลอย่างไร้เดียงสาด้วย% 10 ในตอนท้าย

เช่น

การป้อนข้อมูล: [999999,213412499,34532597,4125159,53539,54256439,353259,4314319,5325329,1242149,142219,1243219,14149,1242149,124419,999999999]

เอาท์พุท: 9


ประทับใจ ด้วยการใช้เวลา 4 ไบต์ขึ้นไปคุณสามารถรับมือกับหอคอยที่สูงกว่าได้มาก: แทนที่n**(t%4+4)ด้วยn**((t-1)%4+1)ดังนั้นคุณจะได้รับn**1แทนที่จะเป็นn**5เช่นนั้นรุ่งโรจน์สำหรับการสังเกตว่าในด่านที่ 4 จะเป็นวัฏจักรที่ดี
เขียนใหม่

1
มีปัญหาหากลำดับมี 0s
เขียนใหม่

@rewritten: จุดดี! ฉันต้องคิดเรื่องนั้น ในทางทฤษฎีแล้วลำดับควรถูกบังคับให้ยกเลิก 2 ขั้นตอนก่อนที่จะเริ่มแรก
Neil Slater

แน่นอนว่าจะต้องใช้รหัสมากขึ้นมากขึ้นอีก 6 ไบต์n<2?n:ก่อนหน้าn**นี้
เขียนใหม่




3

C # (. NET Core) 84 ไบต์

a=>{int i=a.Length-1,j=a[i];for(;i-->0;)j=(int)System.Math.Pow(a[i],j);return j%10;}

ลองออนไลน์!

  • -7 ไบต์ขอบคุณ @raznagul

คุณสามารถบันทึกบางไบต์โดยการลบวงเล็บไปรอบ ๆaและโดยการรวมเงื่อนไขวงกับการลดลง ( for(var i=a.Lengt-1;i-->0;)) แต่ - สถานะusingจะต้องรวมอยู่ในเขานับไบต์
raznagul

@raznagul: ขอโทษฉันค่อนข้างใหม่กับ code-golf ใน C # ตอนนี้ตกลงไหม?
digEmAll

ไม่มีปัญหา. ใช่นี่ใช้ได้แล้ว
raznagul

1
คุณสามารถบันทึกอีก 3 ไบต์โดยใช้ตัวแปรใหม่เพื่อเก็บผลลัพธ์และลบการเข้าถึงดัชนีส่วนใหญ่ไปยังอาร์เรย์: ลองออนไลน์!
raznagul

@raznagul: ยอดเยี่ยม!
digEmAll

3

C (gcc) , 56

  • บันทึกแล้ว 4 ไบต์ขอบคุณ @JonathanFrech

r()เรียกใช้ฟังก์ชันเรียกซ้ำจากแมโครf- ใช้ขีด จำกัด สแต็กปกติ

R;r(int*n){R=pow(*n,n[1]?r(n+1):1);}
#define f(n)r(n)%10

อินพุตที่กำหนดเป็นอาร์เรย์ int ที่สิ้นสุดแล้วไม่มีศูนย์ นี้อยู่ภายใต้สมมติฐานที่ว่าไม่มีของ x nเป็นศูนย์

ลองออนไลน์!


2
) r()r(->
Jonathan Frech

1
นอกจากนี้ถ้าคุณต้องการที่จะใช้ UB คุณสามารถกอล์ฟไปr(int*n){return pow R;r(int*n){R=pow
Jonathan Frech


3

Japtap -h , 7 ไบต์

OvUqp)ì

ลองออนไลน์!

คำอธิบาย:

OvUqp)ì
Ov   )    // Japt eval:
   q      //   Join
  U       //   Input with
    p     //   Power method
      ì   // Split into an array of numbers
-h        // Return the last number

แปลกที่ไม่ได้ผลสำหรับฉัน
Shaggy


@Shaggy : P
Oliver

อาเพื่อเห็นแก่ Jaysis! : \ มันเกิดขึ้นบ่อยขึ้น!
Shaggy

3

Japt -h , 7 6 ไบต์

หากอินพุตสามารถดำเนินการในลำดับย้อนกลับได้ตัวอักษรตัวแรกสามารถลบออกได้

จำกัด 2**53-1ให้

Ôr!p ì

ลองมัน


คำอธิบาย

Ô          :Reverse the array
 r         :Reduce by
  !p       :  Raising the current element to the power of the current total, initially the first element
     ì     :Split to an array of digits
           :Implicitly output the last element

ฉันได้รับคำตอบเดียวกันโดยไม่ต้องตั้งค่าสถานะดังนั้นนี่จึงเป็นวิธีที่ดีที่สุดสำหรับตอนนี้
Nit

@Nit: จนกว่าจะได้รับการยืนยันเราสามารถป้อนข้อมูลในสิ่งที่ตรงกันข้าม :)
Shaggy

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

@Nit ไม่ควรตั้งค่าสถานะ 3 ไบต์โดยฉันทามติ meta?
LegionMammal978

@ LegionMammal978 ไม่มีอีกแล้ว
Shaggy



2

Excel VBA ขนาด 60 ไบต์

ฟังก์ชันหน้าต่าง VBE แบบไม่ระบุชื่อแบบทันทีที่รับอินพุตจากช่วง [A1:XFD1]

s=1:For i=-[Count(1:1)]To-1:s=Cells(1,-i)^s:Next:?Right(s,1)



2

Python 3 , 55 ไบต์

p=lambda l,i=-1:not l or f'{l[0]**int(p(l[1:],0))}'[i:] 

รุ่นเก่ากว่า

p=lambda l,i=-1:len(l)and f'{l[0]**int(p(l[1:],0))}'[i:]or 1    (60 bytes)


มันจะไม่เป็นอย่างนั้นp=lambda...เหรอ? Python ไม่สามารถจัดการกับ lambdas แบบไม่ระบุชื่อซ้ำได้ดังนั้นหากคุณต้องการชื่อฟังก์ชั่นของคุณจะต้องเป็นส่วนหนึ่งของโซลูชันของคุณ
mypetlion


2

Brain-Flakขนาด 161 ไบต์

รวม +1 สำหรับ -r

([][()]){({}[()]<({}<(({}))>[()]){({}<(({})<({}<>)({<({}[()])><>({})<>}{}<><{}>)>)>[()])}{}{}>)}{}({}((()()()()()){})(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})

ลองออนไลน์!

ตัวอย่างที่[3, 4, 2]ใช้เวลานานกว่า 60 วินาทีดังนั้น TIO [4, 3, 2]ใช้การเชื่อมโยง

-rสามารถถอดออกได้ถ้าใส่สามารถนำมาในลำดับที่กลับสำหรับการนับไบต์ 160

# Push stack size -1
([][()])

# While there are 2 numbers on the stack
{({}[()]<

    # Duplicate the second number on the stack (we're multiplying this number by itself)
    ({}<(({}))>[()])

    # For 0 .. TOS
    {({}<

        # Copy TOS
        (({})<

        # Multiple Top 2 numbers
        ({}<>)({<({}[()])><>({})<>}{}<><{}>)

        # Paste the old TOS
        >)

    # End for (and clean up a little)
    >[()])}{}{}

# End While (and clean up)
>)}{}

# Mod 10
({}((()()()()()){})(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})


2

Z80Golfขนาด 36 ไบต์

00000000: cd03 80f5 30fa f1f1 57f1 280d 4f41 15af  ....0...W.(.OA..
00000010: 8110 fd47 1520 f818 ef7a d60a 30fc c60a  ...G. ...z..0...
00000020: cd00 8076                                ...v

ลองออนไลน์!

ชุดทดสอบกำลังแบบ Brute-force

รับอินพุตเป็นไบต์ดิบ จำกัด ที่ 2 ** 8-1

คำอธิบาย

input:
    call $8003    ;      the input bytes
    push af       ; push                 on the stack
    jr nc, input  ;                                   until EOF
    pop af        ; the last byte is going to be pushed twice
    pop af
outer:
    ld d, a       ; d = exponentiation loop counter, aka the exponent
    pop af        ; pop the new base off the stack
    jr z, output  ; The flags are being pushed and popped together with the
                  ; accumulator. Since the Z flag starts as unset and no
                  ; instruction in the input loop modifies it, the Z flag is
                  ; going to be unset as long as there is input, so the jump
                  ; won't be taken. After input is depleted, a controlled stack
                  ; underflow will occur. Since SP starts at 0, the flags
                  ; register will be set to the $cd byte from the very beginning
                  ; of the program. The bit corresponding to the Z flag happens
                  ; to be set in that byte, so the main loop will stop executing
    ld c, a       ; C = current base
    ld b, c       ; B = partial product of the exponentiation loop
    dec d         ; if the exponent is 2, the loop should only execute once, so
                  ; decrement it to adjust that
pow:
    xor a         ; the multiplication loop sets A to B*C and zeroes B in the
mul:              ; process, since it's used as the loop counter
    add c         ; it's definitely not the fastest multiplication algorithm,
    djnz mul      ; but it is the smallest
    ld b, a       ; save the multiplication result as the partial product
    dec d         ; jump back to make the next iteration of either
    jr nz, pow    ; the exponentiation loop or the main loop, adjusting the
    jr outer      ; loop counter in the process
output:           ; after all input is processed, we jump here. We've prepared
    ld a, d       ; to use the result as the next exponent, so copy it back to A
mod:              ; simple modulo algorithm:
    sub 10        ;            subtract ten
    jr nc, mod    ; repeatedly              until you underflow,
    add 10        ; then undo the last subtraction by adding ten
    call $8000    ; output the result
    halt          ; and exit

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.