งาน

ในความท้าทายนี้งานของคุณคือการเขียนโปรแกรมในภาษาการเขียนโปรแกรมLที่ใช้จำนวนเต็มบวกnและแสดงผลรวมของตัวหารที่เหมาะสมของn ( ลำดับ A001065บน OEIS) มันควรจะกลับมาส่งออกที่ถูกต้องสำหรับการใด ๆ1 ≤ n ≤ 10 000 นี่คือผลลัพธ์ 10 รายการแรก:

0, 1, 1, 3, 1, 6, 1, 7, 4, 8

นอกจากนี้โปรแกรมของคุณจะต้องเป็นรูปหลายภาษาปลอมซึ่งหมายถึงสิ่งต่อไปนี้ มันเป็นโปรแกรมที่ถูกต้องในภาษาการเขียนโปรแกรมอื่นL 'และสำหรับแต่ละอินพุต1 ≤ n ≤ 10 (กรณีทดสอบด้านบน) จะส่งคืนผลรวมของตัวหารที่เหมาะสมของnแต่มีบาง11 ≤ n ≤ 10,000ซึ่ง ไม่ส่งคืนผลลัพธ์ที่ถูกต้อง มันอาจส่งคืนสิ่งที่ไม่ถูกต้องวนซ้ำตลอดไปล้มเหลว ฯลฯ มันสามารถให้ผลลัพธ์ที่ผิดสำหรับn ≥ 11ทั้งหมดสำหรับบางคนหรือเพียงอันเดียว

กฎและการให้คะแนน

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

โปรดทราบว่าหากคุณใช้ภาษาการเขียนโปรแกรมที่มีการเข้ารหัสที่ไม่ใช่ ASCII (มีหลายวิธีในเว็บไซต์นี้) ต้องใช้ลำดับไบต์เดียวกันสำหรับทั้งสองภาษา ซึ่งหมายความว่าคุณต้องแปลงระหว่างหน้ารหัสที่แตกต่างกันที่อาจเกิดขึ้นหรือได้รับบทลงโทษสำหรับอักขระ Unicode หลายไบต์

กรณีทดสอบเพิ่มเติม

20 -> 22
36 -> 55
180 -> 366
997 -> 1
2875 -> 869
10000 -> 14211

JavaScript (ES6), V8 / SpiderMonkeyเทียบกับChakra , 66 63 ไบต์

n=>[...Array(n)].map((_,d)=>s+=n%d?0:d,[0,n>10].sort(x=>s=x))|s

การสาธิต

let f =

n=>[...Array(n)].map((_,d)=>s+=n%d?0:d,[0,n>10].sort(x=>s=x))|s

console.log(JSON.stringify(
  [...Array(20)].map((_, n) => n + 1).map(f)
))

เอาท์พุต

ผลลัพธ์ของตัวอย่างข้างต้นบน Chrome และ Firefox (ถูกต้องทั้งหมด):

[0,1,1,3,1,6,1,7,4,8,1,16,1,10,9,15,1,21,1,22]

เอาต์พุตบน Edge (ปิดด้วย 1 เริ่มต้นที่ n = 11):

[0,1,1,3,1,6,1,7,4,8,2,17,2,11,10,16,2,22,2,23]

ทำไม?

ไม่มีการกำหนดอัลกอริทึมโดยข้อกำหนดสำหรับ.sort()วิธีการ ไม่จำเป็นต้องมีเสถียรภาพแม้แต่น้อย ดังนั้นเอนจิ้น JavaScript แต่ละตัวจึงใช้งานได้เอง

อย่างไรก็ตาม[0,1].sort(x=>x)ให้[0,1]กับเครื่องยนต์ทั้งหมด

ดังนั้นความแตกต่างคืออะไร?

สิ่งที่เกิดขึ้นที่นี่คือจักรที่ผ่าน1เป็นพารามิเตอร์แรกของการทำซ้ำครั้งแรก (และเท่านั้น) เพื่อฟังก์ชั่นการโทรกลับ (ขอให้เปรียบเทียบ1กับ0) ในขณะที่ V8 และ SpiderMonkey กำลังผ่าน0(ขอการเปรียบเทียบ0ด้วย1)

คุณสามารถใช้ตัวอย่างต่อไปนี้เพื่อตรวจสอบสิ่งที่เบราว์เซอร์ของคุณกำลังทำอยู่

[0, 1].sort((x, y) => console.log("Let's compare " + x + " with " + y + "!"))

Python 2 และ Python 3, 58 ไบต์

TIO สำหรับ Python 2

TIO สำหรับ Python 3

lambda n:sum(i*(n<11or''==b'')for i in range(1,n)if n%i<1)

มันทำงานในหลาม 2 แต่สำหรับทุก ๆ n> 10 มันจะเอาท์พุท 0 ในหลาม 3
ทั้งหมดเพราะวิธีการที่แตกต่างกันในการเปรียบเทียบสตริงกับไบต์:

• ใน Python 2 '' == b''
• ใน Python 3 '' != b''

JavaScript (Node.js)และPHP , 73 70 ไบต์

function($n){for($d=$i=0;++$i<$n;)$d+=$i*!($n%$i);return"$n">10?0:$d;}

ในทั้งสองภาษานี่เป็นฟังก์ชันที่ไม่ระบุตัวตน JavaScript ให้ผลที่ถูกต้อง แต่ PHP ให้0สำหรับทุกn> = 11

ลอง JS!

ลองใช้ PHP!

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

ภาษาทั้งสองทำสิ่งเดียวกันในตอนแรก: สำทับจาก 1 ถึง n-1 ทำให้ผลรวมการทำงานของตัวเลขทั้งหมดฉันที่n% i = 0

สิ่งที่ทำให้เกิดความแตกต่างในพฤติกรรมคือส่วนสุดท้าย:

return"$n">10?0:$d;

ใน JavaScript "$n"เป็นเพียงตัวอักษรสตริง การเปรียบเทียบ>กับ10มันทำให้มันเป็นตัวเลขโดยปริยาย แต่เนื่องจากมันดูไม่เหมือนตัวเลขมันจึงกลายเป็น NaN NaN ให้เท็จเมื่อเปรียบเทียบกับตัวเลขในทางใดทางหนึ่ง ส่งคืนผลลัพธ์$dเสมอ

อย่างไรก็ตามใน PHP "$n"เป็นสตริงที่มีค่า$nเป็น เมื่อ PHP $nปลดเปลื้องนี้ตัวเลขมันก็จะกลายเป็นค่าของ ถ้ามันมากกว่า10นั้นจะถูกส่งกลับแทน0$d

05AB1E / Jelly ,  9  8 ไบต์

ไบต์รหัส (เลขฐานสิบหก):

d1 a8 4f 71 0d ad 53 fa

การใช้โค้ดเพจของเยลลี่ส่งคืนผลลัพธ์ที่ไม่ถูกต้องสำหรับจำนวนที่มากเกินไป (เช่นอินพุต12คืน12แทน16):

ẎƭOqÆḌS«

ลองออนไลน์!

การใช้โค้ดเพจของ 05AB1Eจะให้ผลลัพธ์ที่ถูกต้อง:

ѨOqмλSú

ลองออนไลน์!

อย่างไร?

05AB1E แยกวิเคราะห์และรวมถึง71( q) ซึ่งแนะนำให้เลิกแล้วหยุดการแยกวิเคราะห์:

ѨOq - Takes input from stdin
Ñ    - get divisors
 ¨   - remove right-most (the input value itself - yielding proper divisors)
  O  - sum
   q - quit (causing an implicit print of the top of the stack)
...мλSú is never parsed

เยลลี่แยกวิเคราะห์โปรแกรมทั้งหมดล่วงหน้าเป็นลิงก์สามรายการเนื่องจากผลของไบต์โดยไม่มีความหมายที่กำหนดƭและqทำหน้าที่เป็นตัวคั่น จุดเริ่มต้นของโปรแกรมคือลิงค์สุดท้าย:

Ẏ - Link 1 (never used), tighten list
...ƭ delimits links 1 & 2)

O - Link 2 (never used), cast from characters to their ordinals
...q delimits link 2 and the main link

ÆḌS« - Main link: number, n
ÆḌ   - proper divisors
  S  - sum
   « - minimum of that and n
     - as a full-program: implicit print

Python 3 / Python 2 , 64 60 58 ไบต์

ขอบคุณ @officialaimm เป็นเวลา 2 ไบต์

lambda n:sum(d*(round((n>10)*.5)==n%d)for d in range(1,n))

ใน Python 3 จะให้ผลลัพธ์ที่ถูกต้อง ในหลาม 2 ouput 10ที่ไม่ถูกต้องสำหรับปัจจัยการผลิตเกิน รหัสนี้ใช้ในการปัดเศษของนายธนาคารซึ่งทำโดย Python 3 แต่ไม่ใช่โดย Python 2

ลองออนไลน์! Python 3 (ถูกต้อง), Python 2 (ผิดn > 10)

Python 3 / Python 2 , 47 ไบต์

lambda n:sum(d*(n%d<1)for d in range(10/n>0,n))

ฟังก์ชันที่ไม่มีชื่อปลอมใน Python 2

ลองออนไลน์สำหรับPython 3หรือPython 2

ใน Python 2 /เป็นการหารจำนวนเต็มพร้อมอาร์กิวเมนต์จำนวนเต็มขณะที่ Python 3 เป็นการหาร

เมื่อnเกินกว่า10 10/nจะประเมินเป็น0ใน Python 2 แต่จะเป็นจำนวนบวกเล็กน้อยใน Python 3 (ซึ่งเป็นจริงมากที่สุดถึงความต้องการสูงสุด10,000อย่างน้อย)

เป็นเช่น10/n>0ประเมินTrueสำหรับงูหลามที่ 3 และrange(10/n>0,n)เทียบเท่ากับrange(1,n)ในขณะที่ในหลาม 2 10/n>0ประเมินFalseเมื่อnเกิน10ครั้นแล้วrange(10/n>0,n)กลายเป็นเทียบเท่ากับการrange(0,n)ก่อให้เกิดความพยายามที่จะดำเนินการแบบโมดูโลศูนย์เลขคณิตยกn%dZeroDivisionError

เยลลี่ / 05AB1E , 12 ไบต์

สิ่งที่เยลลี่เห็น:

11⁻iẎƭO}qÆḌS

ลองออนไลน์!

คำอธิบาย:

qไม่รองรับใน Jelly ดังนั้น Jelly เท่านั้น "เห็น" สิ่งที่ตามqมา

ÆḌS
ÆḌ  Proper divisors
  S Sum

สิ่งที่ 05AB1E เห็น:

11‹iѨO}qмλS

ลองออนไลน์!

คำอธิบาย:

11‹iѨO}qмλS Implicit input multiple times
11           Push 11
  ‹          Less than 11?
   i   }     If equals 1, then
    Ñ         Divisors
     ¨        Remove last
      O       Sum
       q     Implicit print and quit
        м    Negative filter
         λ   Undefined, ignored error
          S  Split into chars

แน่นอนทุกอย่างหลังจาก "เลิก" ไม่ได้เกิดขึ้นจริง