ฉันคิดว่าคนส่วนใหญ่ที่นี่รู้ว่าการแสดงผล 7 หลักสำหรับตัวเลขคืออะไร:

 _         _   _         _    _    _    _    _ 
| |    |   _|  _|  |_|  |_   |_     |  |_|  |_|
|_|    |  |_   _|    |   _|  |_|    |  |_|   _|

เราสามารถกำหนดความแตกต่าง 7 เซกเมนต์ (7SD) ระหว่างสองหลักเป็นจำนวนของเซกเมนต์ที่ต้องสลับเพื่อสลับจากหนึ่งไปยังอีก เช่น 7SD ระหว่าง1และ2เป็น5 (สามส่วนแนวนอนและต่ำกว่าสองส่วนในแนวตั้งจะต้องมีการสลับ) และ 7SD ระหว่าง 6 และ 8 เป็น1

นอกจากนี้เราสามารถกำหนด 7SD ระหว่างตัวเลขสองตัวเพื่อเป็นผลรวมของ 7SD ระหว่างตัวเลขที่เกี่ยวข้อง หากตัวเลขหนึ่งยาวกว่าตัวเลขอื่นเราถือว่าพวกเขาอยู่ในแนวเดียวกันและเพิ่มจำนวนของกลุ่มที่จำเป็นในการแสดงตัวเลขที่สำคัญที่สุดเพิ่มเติมของจำนวนที่มากขึ้น ยกตัวอย่างเช่นพิจารณา 7SD ระหว่าง12345และ549:

  x:  1 2 3 4 5
  y:      5 4 9
7SD:  2+5+2+0+1 = 10

งานของคุณคือการคำนวณ 7SD ระหว่างnและ1 + nให้ n

เพื่อความสะดวกนี่คือตารางเต็มของ 7SD ระหว่างตัวเลขแต่ละตัว แถว_หมายถึงตำแหน่งที่ว่างเปล่า

   _ 0 1 2 3 4 5 6 7 8 9

_  0 6 2 5 5 4 5 6 3 7 6
0  6 0 4 3 3 4 3 2 3 1 2
1  2 4 0 5 3 2 5 6 1 5 4
2  5 3 5 0 2 5 4 3 4 2 3
3  5 3 3 2 0 3 2 3 2 2 1
4  4 4 2 5 3 0 3 4 3 3 2
5  5 3 5 4 2 3 0 1 4 2 1
6  6 2 6 3 3 4 1 0 5 1 2
7  3 3 1 4 2 3 4 5 0 4 3
8  7 1 5 2 2 3 2 1 4 0 1
9  6 2 4 3 1 2 1 2 3 1 0

อินพุต

• nการป้อนข้อมูลเป็นจำนวนเต็มบวกเดียว
• คุณสามารถเขียนโปรแกรมหรือฟังก์ชั่นรับอินพุตผ่าน STDIN (หรือทางเลือกที่ใกล้เคียงที่สุด) อาร์กิวเมนต์บรรทัดคำสั่งหรืออาร์กิวเมนต์ฟังก์ชัน
• คุณอาจสันนิษฐานว่าการป้อนข้อมูลมีค่าน้อยกว่าหนึ่งจำนวนมากที่สุดซึ่งสามารถแสดงด้วยจำนวนเต็มมาตรฐานของภาษาของคุณตราบเท่าที่ประเภทนั้นรองรับอย่างน้อยค่าสูงสุดและรวมถึง 127

เอาท์พุต

• คุณควรพิมพ์จำนวนเต็มเดียว 7SD ระหว่างและnn+1
• คุณสามารถส่งออกผ่านทาง STDOUT (หรือทางเลือกที่ใกล้เคียงที่สุด), ค่าส่งคืนของฟังก์ชันหรืออาร์กิวเมนต์ของฟังก์ชัน (ออก)

เกณฑ์การให้คะแนน

ใช้กฎของรหัส - กอล์ฟมาตรฐานรหัสที่สั้นที่สุด (เป็นไบต์) ชนะ

กรณีทดสอบ

ด้วยเหตุปิดบังบางลำดับนี้ไม่ได้อยู่ใน OEIS เลยถึงแม้จะมีลำดับที่เกี่ยวข้องอย่างใกล้ชิดA123587 นี่คือตัวเลข 100 ตัวแรก (เริ่มต้นด้วยn = 1, 2, 3, ...):

5, 2, 3, 3, 1, 5, 4, 1, 4, 4, 5, 2, 3, 3, 1, 5, 4, 1, 7, 4, 5, 2, 3, 3, 1, 
5, 4, 1, 4, 4, 5, 2, 3, 3, 1, 5, 4, 1, 5, 4, 5, 2, 3, 3, 1, 5, 4, 1, 5, 4, 
5, 2, 3, 3, 1, 5, 4, 1, 3, 4, 5, 2, 3, 3, 1, 5, 4, 1, 7, 4, 5, 2, 3, 3, 1, 
5, 4, 1, 6, 4, 5, 2, 3, 3, 1, 5, 4, 1, 3, 4, 5, 2, 3, 3, 1, 5, 4, 1, 6, 4

อินพุตแรกที่ 7SD มากกว่า 9 1999ควรให้ผลลัพธ์ 11 นี่คือตัวอย่างที่มีขนาดใหญ่กว่าอื่น ๆ :

n          7SD
1999        11
12345        1
999999      14
5699999     15
8765210248   1

เยลลี่ , 25 22 21 20 ไบต์

‘DṁDḟ"DFị9979482ḃ5¤S

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

พื้นหลัง

เราเพิ่มค่าอินพุตn ก่อนและทิ้งตัวเลขทั้งหมดของn + 1ที่ไม่เปลี่ยนแปลง

ตัวอย่างเช่นถ้าnคือ5699999เราจะได้สิ่งต่อไปนี้

n     : 5700000
n + 1 : 5699999
Result:  700000

ตัวเลขทั้งหมดในผลลัพธ์นี้มีจำนวนเซ็กเมนต์ที่แน่นอนที่ต้องสลับ เราสามารถแปลงรายการสลับเป็นฐานที่ 5เพื่อบันทึกไบท์ได้

digit:   1 2 3 4 5 6 7 8 9 0
toggles: 4 5 2 3 3 1 5 4 1 2

ผลลัพธ์เป็นเพียงผลรวมของแต่ละสลับ

งานนี้สำหรับค่ามากที่สุดของnแต่การดูแลเป็นพิเศษจะต้องดำเนินการถ้า1 + nมีตัวเลขมากกว่าn ในกรณีนี้ตัวเลขทั้งหมดจะต้องมี9 's และเราแก้ปัญหานี้โดยการสับปิดท้าย0จาก1 + n

ตัวอย่างเช่นถ้าnคือ999999เราจะได้สิ่งต่อไปนี้

n     :  999999
n + 1 : 1000000
Result: 100000

สิ่งนี้ได้ผลเพราะผู้นำ1ประเมินถึง4 toggles (ระยะห่างระหว่าง0ถึง1 ) ในขณะที่จำนวน toggles ที่แท้จริงคือ2 (ระยะห่างระหว่าง0ถึง1 ) และการระงับ 1 trailing 0จะลบ2 toggles ออกจากผลรวม

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

‘DṁDḟ"DFị9979482ḃ5¤S  Main link. Argument: n

‘                     Compute n+1.
 D                    Convert n+1 from integer to base 10.
   D                  Convert n from integer to base 10.
  ṁ                   Mold the left result as the right result.
                      This chops of a 0 if n+1 has more digits than n.
    ḟ"D               Vectorized filter-false with the base 10 digits of n.
                      This removes the digits from n+1 that are identical to
                      the corresponding digits of n.
       F              Flatten the resulting list of lists.
         9979482ḃ5¤   Convert 9979482 to bijective base 5.
                      This yields [4, 5, 2, 3, 3, 1, 5, 4, 1, 2].
        ị             Retrieve the digits at the right that correspond to the
                      indices at the left.
                   S  Compute the sum of the results.

JavaScript (ES6), 46 40 ไบต์

f=n=>n?+"452331541"[n%10]||f(n/10|0)+2:2

สูตรทางเลือก46 46ไบต์เช่นกัน:

f=n=>n?26523308>>n%10*3&7||f(n/10|0)+2:2

แก้ไข: บันทึกแล้ว 6 ไบต์ขอบคุณ @xsot

Python 50 50ไบต์

f=lambda n:26523308-0**n*2>>n%10*3&7or f(n/10)+2

คำอธิบาย

ฟังก์ชั่นนี้ทำงานกับตัวเลขที่มีนัยสำคัญน้อยที่สุดnโดยรวม 7SD ของตัวเลขเมื่อเพิ่มขึ้นทีละหนึ่งจนกระทั่งหลังจากไม่ใช่9ตัวเลขแรก

26523308เป็น bitmask ที่ encodes 0-8แมปสำหรับตัวเลขที่ เมื่อn=0ใดซึ่งจะเกิดขึ้นเมื่อnประกอบด้วย9s เท่านั้นคำตอบจะถูกปิดโดยสอง 0**n*2นี้จะชดเชยโดยการแสดงออก สำหรับหลัก9bitmask จะประเมินค่าเป็นศูนย์ซึ่งจะทริกเกอร์การโทรซ้ำในขณะที่เพิ่ม2ลงใน 7SD

05AB1E , 31 30 28 27 26 ไบต์

รหัส:

9Ü©T%•2X›ùì•sè¹g®g-·¹Ú9Q·O

คำอธิบาย ( ล้าสมัย ):

9Ü                              # Trim off trailing 9's
  ©                             # Copy this into the register
   T%                           # Get the last non-9 digit
     žh                         # Short for 0123456789
       •2X›ù앧                 # Compressed version of 4523315412
               ‡                # Transliterate

เรากำลังเปลี่ยนข้อมูลต่อไปนี้เป็นตัวเลขที่ไม่ใช่ 9 หลักสุดท้าย:

0 -> 4
1 -> 5
2 -> 2
3 -> 3
4 -> 3
5 -> 1
6 -> 5
7 -> 4
8 -> 1
9 -> 2

สำหรับกรณีพิเศษ:

                ¹g              # Get the length of the input
                  ®g            # Get the length of the input with all trailing 9 gone
                    -           # Substract, giving the number of 9's at the end of 
                                  the input
                     2*         # Multiply by two
                       O        # Sum everything up
                        ¹Ú      # Uniquify the input
                          9Qi   # If this is equal to 9 (only 9's in the input)
                             Ì  #   Increment by 2 (_ -> 1)

ใช้การเข้ารหัสCP-1252 ลองออนไลน์! .

ทางเลือก 28 D[¤©•2X›ùì•sès®9Ê#¨]\rÚ9Q4*Oไบต์:

Java, 63 ไบต์

โลกถูกต้องเนื่องจาก Python ผ่าน Java อีกครั้ง

สาเหตุ, รู้แล้ว, Java

int f(int n){return n>0?n%10<9?26523308>>n%10*3&7:2+f(n/10):2;}

ดูมันบน ideone

maxes ออกที่ 2147483647 เป็นที่ของ Integer.MAX_VALUEJava

นี่คือพอร์ตของคำตอบหลามของฉันซึ่งเป็นพอร์ตของคำตอบที่ ES6

MATL , 61 39 36 ไบต์

tQvV15\'3dAsMh818RG5'6Y27WZaw)Z}Z~Bz

ลองออนไลน์!

คำอธิบาย

tQv            % Implicit input. Duplicate, add 1, concatenate vertically
V              % Convert to 2D char array: each number in a row, possibly left-padded 
               % with a space
15\            % Modulo 15. With modular indexing this corresponds to the order
               % '9', ' ', '0', '1', ..., '8'
'3dAsMh818RG5' % This string encodes active segments for each of the 11 chars
6Y2            % Source alphabet printable ASCII chars (predefined literal)
7W             % Target alphabet: [0 1 ... 127]
Za             % Base conversion: decode string into vector of 11 numbers, where each
               % number from 0 to 127 encodes the 7-segment representation of a digit,
               % in the order '9', ' ', '0', '1', ..., '8'
w              % Swap top two elements in stack
)              % Use as index. Gives 2-row array, where each column is a digit 
Z}             % Split into the two rows
Z~             % Bitwise XOR, elementwise
B              % Convert to binary. Each number gives a row
z              % Number of nonzero elements. Implicitly display

จูเลีย 44 ไบต์

!x=x<1?2:(t=x%10÷1)<9?3045058÷6^t%6:2+!.1x

ลองที่นี่

เดนนิสบันทึกไบต์!

Python ขนาด71 66 ไบต์

48 ไบต์โดย xsot คณิตศาสตร์เวทมนต์มากขึ้น!

f=lambda n:(2+f(n/10)if n%10==9else 26523308>>n%10*3&7)if n else 2

ดูมันบน ideone

เพราะคำตอบของงูหลามก่อนหน้านี้ไม่ได้ผลและยังห่างไกลจากความเหมาะสม พอร์ตที่เรียบง่ายของรุ่นก่อนหน้า ES6 ตอนนี้ใช้ twiddling บิต (จากสูตรทางเลือก ES6) เพื่อตัดการแสดง!

สามารถทำงานกับ Python 3 ได้อย่างชัดเจนโดยใช้ floordiv สำหรับ +1 ไบต์

Jolf, 32 ไบต์

Ώ?H?<γ%Ht9P."452331541"γ+2Ώc/Ht2

ลองที่นี่!

คำอธิบาย

นี่เป็นการถ่ายทอดคำตอบของนีล

Ώ?H?<γ%Ht9P."452331541"γ+2Ώc/Ht2
Ώ                                 define a function Ώ of H
 ?H                            2  (when H is zero, return is 2)
      %Ht                         H mod 10
     γ                            γ = ^
   ?<    9                        is it less than 9?
                                  if so:
           ."452331541"γ           get the γth element of that string
          P                        as a number
                                  else
                        +2         add two to
                          Ώ        Ώ over
                           c/Ht    int(H / 10)

Pyth - 78 30 27 ไบต์

คนแรกนั้นน่าอาย

s@LjC"
(J"ThC{I#.tjRThBQT

Test Suite

J, 53 ไบต์

2:`((2+10$:@<.@%~[)`(6|3045058<.@%6^])@.(9>])10&|)@.*

แต่เดิมตั้งอยู่บนพื้นฐานของนีล @ วิธีการแก้ปัญหา จากนั้นปรับตัวดีขึ้นโดยการบันทึกไบต์โดยใช้สูตรเดียวกันในลินน์ @ วิธีการแก้ปัญหา

เวอร์ชัน 54 ไบต์ขึ้นอยู่กับสตริงคือ

2:`((2+10$:@<.@%~[)`('452331541'".@{~])@.(9>])10&|)@.*

การใช้

   f =: 2:`((2+10$:@<.@%~[)`(6|3045058<.@%6^])@.(9>])10&|)@.*
   f 1999
11
   f 1999 12345 999999 5699999 8765210248
11 1 14 15 1

เรติน่า 34 ไบต์

M!`.9*$
^9
0
T`d`4523315412
.
$*
.

ลองออนไลน์! (บรรทัดแรกช่วยให้สามารถประมวลผลกรณีทดสอบหลายรายการพร้อมกันได้)

คำอธิบาย

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

M!`.9*$

การจับคู่นี้ ( M) regex .9*$คือตัวเลขตัวแรกที่คั่นด้วย9s จากจุดสิ้นสุดเท่านั้น !บอก Retina เพื่อแทนที่การป้อนข้อมูลที่มีการแข่งขันครั้งนี้ทิ้งทุกอย่างที่ไม่ได้ส่งผลกระทบต่อ 7SD

^9
0

ถ้าใส่ตอนนี้เริ่มต้นด้วยการ9ที่หมายถึงการป้อนข้อมูลของตัวเองประกอบด้วยเฉพาะของ9s เพื่อตอบสนองความต้องการการแสดงผล 7 ส่วนต้องเพิ่มซึ่งค่าใช้จ่าย1 2วิธีที่ง่ายที่สุดในการจัดการสิ่งนี้คือการแทนที่ผู้นำ9ในกรณีนี้ด้วย a 0เนื่องจากต้นทุนการเพิ่ม a 9(เป็น0) 2และต้นทุนการเพิ่ม0(เป็น1) คือ4สิ่งนี้ทำให้ต้นทุนโดยรวมสูงขึ้น2ตามที่ต้องการ

T`d`4523315412

ตอนนี้เรามีขั้นตอนการทับศัพท์ซึ่งจะแทนที่แต่ละหลักด้วยค่าใช้จ่ายสำหรับการเพิ่มขึ้นของมัน (ตั้งแต่dขยายไป0123456789) โปรดทราบว่านี่เป็นส่วนย่อยแรกของตาราง 7SD

.
$*

สิ่งนี้จะแทนที่แต่ละหลักnด้วยnสำเนาของ1มันคือมันจะแปลงแต่ละหลักเป็นเอกและเนื่องจากไม่มีตัวคั่นเพิ่มเข้าด้วยกันทันที

.

ในที่สุดเราก็นับจำนวนตัวอักษร (เช่นจำนวนการจับคู่ของ.) ในผลลัพธ์ซึ่งจะแปลงผลรวมของยูนารีกลับเป็นทศนิยม