Saya pikir sebagian besar orang di sini tahu apa tampilan 7-segmen untuk digit:

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

Kita dapat mendefinisikan perbedaan 7-segmen (7SD) antara dua digit menjadi jumlah segmen yang perlu diaktifkan untuk beralih dari satu ke yang lain. Misalnya 7SD antara 1dan 2adalah 5 (tiga segmen horisontal dan lebih rendah dua segmen vertikal perlu toggle), dan 7SD antara 6 dan 8 adalah 1 .

Selanjutnya, kita dapat mendefinisikan 7SD antara dua angka menjadi jumlah 7SD antara digit yang sesuai. Jika satu nomor lebih panjang dari yang lain, kami mengasumsikan mereka benar-rata dan menambahkan jumlah segmen yang diperlukan untuk menampilkan digit tambahan paling signifikan dari nomor yang lebih besar. Sebagai contoh, perhatikan 7SD antara 12345dan 549:

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

Tugas Anda adalah menghitung 7SD antara n dan n +1 , diberikan n .

Untuk kenyamanan, berikut adalah tabel lengkap 7SD antara masing-masing digit. Baris _mewakili posisi kosong.

   _ 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

Memasukkan

• Input adalah bilangan bulat positif tunggal n.
• Anda dapat menulis program atau fungsi, mengambil input melalui STDIN (atau alternatif terdekat), argumen baris perintah atau argumen fungsi.
• Anda dapat mengasumsikan bahwa input paling banyak kurang dari jumlah terbesar yang dapat diwakili oleh tipe integer standar bahasa Anda, selama tipe tersebut mendukung setidaknya nilai hingga dan termasuk 127.

Keluaran

• Anda harus mencetak satu bilangan bulat, 7SD antara ndan n+1.
• Anda dapat menampilkan melalui STDOUT (atau alternatif terdekat), nilai pengembalian fungsi atau argumen fungsi (keluar).

Mencetak gol

Standar kode-golf aturan berlaku, kode terpendek (dalam bytes) menang.

Uji Kasus

Untuk beberapa alasan yang tidak jelas, urutan ini belum ada dalam OEIS, meskipun ada urutan yang terkait erat A123587 . Berikut adalah 100 angka pertama (dimulai dengan 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

Input pertama yang 7SD lebih besar dari 9 adalah 1999yang harus menghasilkan 11. Berikut adalah beberapa contoh yang lebih besar:

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

Jelly , 25 22 21 20 byte

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

Cobalah online! atau verifikasi semua kasus uji .

Latar Belakang

Kami pertama-tama menambahkan input n dan membuang semua digit n +1 yang belum berubah.

Misalnya, jika n adalah 5699999 , kita mendapatkan yang berikut ini.

n     : 5700000
n + 1 : 5699999
Result:  700000

Semua digit dalam hasil ini memiliki jumlah segmen tetap yang harus di-toggle. Kita dapat mengonversi daftar toggle ke bijective base 5 untuk menghemat beberapa byte.

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

Output hanyalah jumlah dari matikan individu.

Ini berfungsi untuk sebagian besar nilai n , tetapi perhatian khusus harus diambil jika n +1 memiliki lebih banyak digit daripada n . Dalam hal ini, semua digit harus 9 's, dan kami menyelesaikan masalah ini dengan memotong 0 dari n + 1 .

Sebagai contoh, jika n adalah 999999 , kita mendapatkan yang berikut ini.

n     :  999999
n + 1 : 1000000
Result: 100000

Ini berfungsi karena angka 1 yang dievaluasi menjadi 4 toggle (jarak antara 0 dan 1 ), sedangkan jumlah toggle yang sebenarnya adalah 2 (jarak antara 0 dan 1 ), dan menekan satu trailing 0 menghilangkan 2 toggle dari jumlah.

Bagaimana itu bekerja

‘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 byte

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

Formulasi alternatif, juga 46 40 byte:

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

Sunting: Disimpan 6 byte berkat @xsot.

Python, 50 48 byte

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

Penjelasan

Fungsi ini beroperasi pada digit paling signifikan dari angka tersebut n, menjumlahkan 7SD dari digit ketika ditambah satu hingga setelah non- 9digit pertama .

26523308adalah bitmask yang mengkodekan pemetaan untuk digit 0-8. Ketika n=0, yang hanya terjadi ketika nhanya terdiri dari 9s, jawabannya akan mati oleh dua. Ini dikompensasi oleh ekspresi 0**n*2. Adapun digit 9, bitmask mengevaluasi ke nol yang akan memicu panggilan rekursif sambil menambahkan 2ke 7SD.

05AB1E , 31 30 28 27 26 byte

Kode:

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

Penjelasan ( kedaluwarsa ):

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

Kami mengubah yang berikut ini menjadi non-9 digit terakhir:

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

Untuk kasus khusus:

                ¹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)

Menggunakan pengkodean CP-1252 . Cobalah online! .

28 byte alternatif: D[¤©•2X›ùì•sès®9Ê#¨]\rÚ9Q4*O.

Java, 63 byte

Dunia dikoreksi sebagai Python melewati Jawa sekali lagi

Karena, kau tahu, Jawa.

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

Lihat di ideone

Maksimal keluar di 2147483647, karena itu adalah Jawa Integer.MAX_VALUE.

Ini adalah port jawaban Python saya yang merupakan port jawaban ES6 .

MATL , 61 39 36 byte

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

Cobalah online!

Penjelasan

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

Julia, 44 byte

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

Coba di sini.

Dennis menyimpan satu byte!

Python, 71 66 byte

48 byte oleh xsot . Matematika lebih ajaib!

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

Lihat di ideone

Karena jawaban Python sebelumnya tidak berfungsi dan jauh dari optimal. Port sederhana dari versi ES6 sebelumnya . Sekarang menggunakan bit twiddling (dari formulasi alternatif ES6) untuk memotong gips!

Dapat dibuat untuk bekerja dengan Python 3 dengan secara eksplisit menggunakan floordiv untuk +1 byte.

Jolf, 32 byte

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

Coba di sini!

Penjelasan

Ini adalah perubahan dari jawaban Neil.

Ώ?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 byte

Yang pertama itu memalukan.

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

Test Suite .

J, 53 byte

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

Awalnya berdasarkan solusi @ Neil . Kemudian ditingkatkan dengan menyimpan byte menggunakan rumus yang sama dalam solusi @ Lynn .

Versi 54 byte berdasarkan string adalah

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

Pemakaian

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

Retina , 34 byte

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

Cobalah online! (Baris pertama hanya memungkinkan pemrosesan beberapa kasus uji sekaligus.)

Penjelasan

Seperti sebagian besar jawaban telah ditemukan sekarang, kita tidak perlu menggunakan tabel lengkap, karena hanya 9perubahan non- digit paling signifikan ketika bertambah. Begitulah cara jawaban ini bekerja.

M!`.9*$

Ini cocok dengan ( M) regex .9*$yaitu digit pertama yang hanya dipisahkan oleh 9s dari akhir. The !memberitahu Retina untuk mengganti input dengan pertandingan ini, membuang segala sesuatu yang tidak mempengaruhi 7SD tersebut.

^9
0

Jika input sekarang dimulai dengan 9itu artinya, input itu sendiri hanya terdiri dari 9s, sehingga tampilan 7-segmen perlu menambahkan 1yang biaya 2. Cara paling sederhana untuk menangani ini adalah mengganti yang utama 9dalam hal ini dengan a 0, karena biaya penambahan 9(ke 0) adalah 2dan biaya penambahan 0(ke 1) adalah 4, jadi ini meningkatkan biaya keseluruhan 2sesuai kebutuhan.

T`d`4523315412

Sekarang kami memiliki tahap transliterasi yang menggantikan setiap digit dengan biaya untuk penambahannya (karena dekspansi ke 0123456789). Perhatikan bahwa ini adalah subdiagonal pertama dari tabel 7SD.

.
$*

Ini menggantikan setiap digit ndengan nsalinan 1, yaitu mengkonversi setiap digit ke unary, dan karena tidak ada pemisah segera menambahkannya bersama-sama.

.

Akhirnya, kami menghitung jumlah karakter (yaitu jumlah kecocokan dari .) dalam hasil, yang mengubah jumlah unary kembali ke desimal.