Berkongsi algoritma untuk mengira bilangan langkah digital yang dilaksanakan dalam kemahiran JavaScript_javascript

Dalam dua hari yang lalu, saya melihat github master tertentu dan mendapati bahawa dia lebih berminat dengan algoritma. Saya melihat salah satu algoritma pengiraan langkah untuk mengira nombor, jadi saya laksanakan satu diri saya.

Penerangan algoritma dan prinsip pelaksanaan

Diberi nombor integer, kira berapa banyak pergerakan yang boleh mencapai matlamat Contohnya, nombor 4 boleh mempunyai pergerakan berikut

Salin kod Kod adalah seperti berikut:

[ 1, 3 ]
          [ 4 ]
[ 1, 1, 2 ]
                            [ 2, 2 ]
[ 1, 1, 1, 1 ]

Malah, kesimpulan berikut boleh dibuat melalui gabungan di atas.

1. Senaraikan dahulu semua kombinasi yang itemnya 1
2. Dari kiri ke kanan, gabungan yang itemnya ialah 1
3. Ulang set di atas, cari indeks 1 dalam item, dan kemudian hitung nilai 2 item dari kiri Hasilnya ialah operasi rekursif
4. Kecualikan situasi 1 dan 2

Tiga fungsi alat berikut disediakan:

Salin kod Kod adalah seperti berikut:

// Kira nilai dalam tatasusunan
fungsi mengira(arg){
Kembalikan eval(arg.join(' '));
}

//Keluarkan nilai tatasusunan
fungsi cetak(arg){
untuk(var i = 0; i < arg.length; i ){
console.log(arg[i]);
}
}

// Semak sama ada ia adalah pergerakan ke hadapan atau ke belakang
fungsi mempunyaiRepeat(src, dist){
Jika (dist.length != 2) kembalikan palsu;
untuk(var i = 0, len = src.length; i < len ; i ){
If(dist.length == src[i].length){
If(dist[0] == src[i][1]){
                    kembali benar;
            }
}
}
Kembalikan palsu;
}

Pelaksanaan algoritma dipaparkan di bawah:

Salin kod Kod adalah seperti berikut:

fungsi countSteps(n){
kiraan var = 0,i,j = 0;
hasil var = [];
var newresult = [];
var sumber = [];
var temparg = [];
// Hasilkan tatasusunan dengan semua item ialah 1
untuk(i = 1; i <= n ; i ){
           sumber.push(1);
}
Jika(n > 2){
untuk(j = 1; j < n - 1; j ){
temparg.length = 0;
                  jika(j < n - 1){
// Jana tatasusunan dengan item meningkat 1 dari kiri ke kanan
                                                       // 1.. 11.. 111..
                   Array.prototype.push.apply(temparg, source.slice(0, j));
              temparg.push(calculate(source.slice(j,n)));
                  result.push(temparg.slice(0));
                         // Ulangi kandungan tatasusunan sehingga tiada 1 dalam item
                   bergabung(temparg.slice(0));
            }
}
}
// Gabungkan item tatasusunan yang mengandungi 1
// 111->21->3
function combine(arg){
var linearg = [];
untuk(var i = 0; i < arg.length; i ){
Jika(arg[i] == 1){
Jika(i ==0 || i == 1){
linearg.push(calculate(arg.slice(0,2)));
                      Array.prototype.push.apply(linearg, arg.slice(2, arg.length));
Jika(!hasRepeat(hasil, linearg)){
result.push(linearg);
                          bergabung(linearg.slice(0));
                 }
                    kembali;
                }
            }
}
}
//Apabila 2, terdapat satu item lagi daripada 1
Jika(n == 2){
         result.push([2]);
}
// Tambahkan kes di mana kesemuanya adalah 1
result.push(sumber);
// Keluarkan semua langkah
Cetak(hasil);
console.log('Sejumlah:' result.length 'bilangan pergerakan');
}

//Lari
countSteps(4);

// Keluarkan kandungan berikut
/*
[ 1, 3 ]
[ 4 ]
[ 1, 1, 2 ]
[ 2, 2 ]
[ 1, 1, 1, 1 ]
Terdapat sejumlah: 5 jenis berjalan
*/

Ringkasan

Algoritma ini sebenarnya boleh digunakan untuk jenis permainan tertentu Apabila jarak antara dua objek adalah tetap, semua kemungkinan boleh diproses, ia juga boleh digunakan untuk tempat lain biasa dengan algoritma. Terdapat sedikit amalan, tetapi ia masih mempunyai nilai Algoritma sebenarnya digunakan dalam banyak butiran UI saya akan menyiarkan lebih banyak artikel tentang algoritma apabila saya mempunyai masa pada masa hadapan 🎜>