Pemecahan Masalah-1

Terbalik Pertama
Minta fungsi FirstReverse( str ) ambil parameter str yang diteruskan dan kembalikan string
dalam urutan terbalik. Sebagai contoh: jika input string adalah "Hello World and Coders" maka program
Anda harus mengembalikan string sredoC dna dlroW olleH .
Contoh
Masukan: "coderbyte"
Keluaran: etybredoc
Masukan: "Saya Suka Kode"

Keluaran: edoC evoL I
fungsi FirstReverse(str) {
var arr = str.split('');

arr.mundur();
return arr.bergabung('');
}
// pertahankan panggilan fungsi ini di sini

// untuk melihat cara memasukkan argumen dalam JavaScript gulir ke bawah
FirstReverse(readline());
biarkan newString = '';

for (biarkan i = str.panjang-1; i >= 0; i--) {
stringbaru += str[i];
}
kembalikan string baru;

}

// kode di sini
return str.split('').reverse().join('');

Faktorial Pertama
Apakah fungsi FirstFactorial( num ) mengambil parameter num yang diteruskan dan
mengembalikan faktorialnya. Misalnya: jika num = 4, maka program Anda harus mengembalikan (4 * 3
* 2 * 1) = 24. Untuk kasus uji, kisarannya antara 1 dan 18 dan masukannya akan selalu berupa bilangan
bulat.
Contoh
Masukan: 4
Keluaran: 24
Masukan: 8
Keluaran: 40320
fungsi FaktorPertama(bil) {
misalkan faktorial = 1;
for (biarkan i = 1; i <= num; i++) {

faktorial *= i;
}
kembali faktorial;

FirstFactorial(readline());
// kode di sini
jika (num < 0) kembalikan NaN;
kembali (bil > 1) ? FirstFaktorial(bil - 1) * num : 1;

biarkan jawaban = 1;
for (biarkan indeks = 1; indeks <= num; indeks++) {
jawaban *= indeks;
}
kembali jawaban;

Kata Terpanjang
Mintalah fungsi LongestWord( sen ) ambil parameter sen yang diteruskan dan kembalikan kata
terbesar dalam string. Jika ada dua kata atau lebih yang memiliki panjang yang sama, kembalikan kata
pertama dari string dengan panjang tersebut. Abaikan tanda baca dan anggap sen tidak akan kosong.
Contoh
Masukan: "menyenangkan&!! waktu"

Keluaran: waktu
Masukan: "Saya suka anjing"

Keluaran: cinta
function Kata Terpanjang(sen) {
sen = sen.trim();
sen = sen.ganti(/[â-zA-Zsd]/g, '');
var arr = sen.split(' ');
arr.sort(function(a, b) {return b.length - a.length});
return arr.shift();
// kode di sini
sen kembali;

Kata Terpanjang(readline());
let validCharacters =
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
biarkan maxLength = 0;
biarkan kata terpanjang = '';
for (misalkan i = 0, panjang = 0, kata = ''; i < sen.panjang; i++) {

biarkan c = sen[i];
if (validCharacters.includes(c)) {
panjang++;
kata +=c;
} kalau tidak {
panjang = 0;
kata = '';
}
if (panjang > maxLength) {

maxLength = panjang;
kata terpanjang = kata;
}
}
kembali kata terpanjang;


var dipangkas = sen.ganti(/[^\w]/g, ' ');
var kata = trimmed.split(/\s+/);
var kata terpanjang = kata.urutkan(fungsi(a, b) {kembali b.panjang - a.panjang;})
[0];
kembali kata terpanjang;
}

Perubahan Surat
Mintalah fungsi LetterChanges( str ) mengambil parameter str yang diteruskan dan
memodifikasinya menggunakan algoritme berikut. Ganti setiap huruf dalam string dengan huruf yang
mengikutinya dalam alfabet ( mis. c menjadi d, z menjadi a). Kemudian gunakan huruf kapital setiap
vokal dalam string baru ini (a, e, i, o, u) dan akhirnya kembalikan string yang dimodifikasi ini.
Contoh
Masukan: "halo*3"
Keluaran: Ifmmp*3
Masukan: "waktu yang menyenangkan!"
Keluaran: gvO Ujnft!
function Perubahan Huruf(str) {
str = str.trim().toLowerCase();
var len = str.panjang;
var newStr = '';
untuk (var i = 0; i < len; i++) {

if (/[a-ce-gi-mo-su-y]/.test(str[i])) {
newStr += String.fromCharCode(((str[i].charCodeAt(0) - 18) % 26) + 97)
}
lain jika (/[zdhnt]/.test(str[i])) {
newStr += String.fromCharCode(((str[i].charCodeAt(0) - 18) % 26) + 65);
}
kalau tidak {
newStr += str[i];
}
}
kembalikan str baru;

LetterChanges(readline());
biarkan ValidCharacters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

for (biarkan i = 0; i < str.panjang; i++) {
if (validCharacters.includes(str[i])) {
biarkan char = str.charCodeAt(i);
stringbaru += (str[i] === 'z' || str[i] === 'Z') ?
String.fromCharCode(char - 25) : String.fromCharCode(char + 1);
} kalau tidak {
}
}
biarkan vokal = 'aeiou';
biarkan finalString = '';
// kapitalisasi vokal
for (biarkan i = 0; i < newString.length; i++) {
if (vokal.termasuk(newString[i])) {
finalString += newString[i].toUpperCase();
} kalau tidak {
finalString += newString[i];
}
}
kembalikan string akhir;


str = str.replace(/[a-zA-Z]/g, function(ch) {
if (ch === 'z') kembalikan 'a';
lain jika (ch === 'Z') kembalikan 'A';
selain itu kembalikan String.fromCharCode(ch.charCodeAt(0) + 1);
});
return str.replace(/[aeiou]/g, function(ch) {

kembali ch.toUpperCase();
});
}

// untuk melihat cara memasukkan argumen dalam JavaScript, gulir ke bawah
Penambahan Sederhana
Miliki fungsi SimpleAdding( num ) menjumlahkan semua angka dari 1 hingga num . Misalnya: jika
inputnya 4 maka program Anda harus mengembalikan 10 karena 1 + 2 + 3 + 4 = 10. Untuk kasus uji,
parameter num akan berupa angka dari 1 hingga 1000.
Contoh
Masukan: 12
Keluaran: 78
Masukan: 140
Keluaran: 9870
function SimpleAdding(num) {
jika (bil === 1) {
kembali 1;
}
kalau tidak {
return num + SimpleAdding(num -1);
}
}

SimpleAdding(readline());
biarkan jumlah = 0;
untuk (i = 1; i <= num; i++) {
jumlah += saya;
}
jumlah pengembalian;

// kode di sini
if (num < 1) kembalikan NaN;
lain jika (bil === 1) kembalikan 1;
return SimpleAdding(bil - 1) + num;
}

Huruf Kapital
Memiliki fungsi LetterCapitalize( str ) ambil parameter str yang diteruskan dan huruf besar
huruf pertama dari setiap kata. Kata-kata akan dipisahkan hanya dengan satu spasi.
Contoh
Masukan: "halo dunia"

Keluaran: Halo Dunia
Masukan: "saya berlari ke sana"

Keluaran: Saya Berlari Ke Sana
function LetterCapitalize(str) {
kataarr = str.split(" ");
for (var i = 0, n = wordarr.length; i < n; i++) {

kataarr[i] = kataarr[i][0].toUpperCase() + kataarr[i].slice(1);
}
str = wordarr.join(" ");
kembali str;

LetterCapitalize(readline());

for (biarkan i = 0, KataBaru = true; i < str.length; i++) {
if (kata baru) {
stringbaru += str[i].toUpperCase();
} kalau tidak {
}
KataBaru = (str[i] === ' ') ? benar salah;

}

}

// kode di sini
return str.split(/s+/).peta(fungsi(kata) {
kembalikan kata[0].toUpperCase() + kata.slice(1);
}).bergabung(' ');
}

Simbol Sederhana
Mintalah fungsi SimpleSymbols( str ) mengambil parameter str yang diteruskan dan menentukan
apakah itu urutan yang dapat diterima dengan mengembalikan string true atau false . Parameter str
akan terdiri dari simbol + dan = dengan beberapa karakter di antaranya ( mis. ++d+===+c++==a) dan
agar string benar, setiap huruf harus dikelilingi oleh simbol + . Jadi string ke kiri akan salah. String tidak
akan kosong dan akan memiliki setidaknya satu huruf.
Contoh
Masukan: "+d+=3=+s+"
Keluaran: benar
Masukan: "f++d+"
Keluaran: salah
function SimpleSymbols(str) {
if (/^[a-zA-Z]/.test(str) || /[a-zA-Z]$/.test(str)) {
kembali salah;
}
lain jika (/[^+][a-zA-Z]/.test(str) || /[a-zA-Z][^+]/.test(str)) {
kembali salah;
}
kalau tidak {
kembali benar;
}

SimpleSymbols(readline());
jika (str === '') {

kembali 'salah';
}
biarkan hasil = str.split('').every(letterEval);
mengembalikan hasil? 'benar salah';
fungsi hurufEval(huruf, indeks) {

biarkan huruf = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
if (huruf.termasuk(huruf)) {
// Periksa karakter pertama atau terakhir
if (indeks === 0 || indeks === str.panjang - 1) {
// Huruf adalah karakter pertama atau terakhir, huruf gagal
kembali salah;
}
if (str[indeks - 1] === '+' && str[indeks + 1] === '+') {

kembali benar;
}
} kalau tidak {
// Abaikan bukan huruf
kembali benar;
}
}

// kode di sini
if (str.match(/[^+][A-Za-z][^+]/g)) return false;
lain jika (str.match(/[+][A-Za-z][^+]/g)) return false;
lain jika (str.match(/[^+][A-Za-z][+]/g)) return false;
kembali benar;
}

Periksa Angka
Minta fungsi CheckNums( num1 , num2 ) ambil kedua parameter yang diteruskan dan kembalikan
string true jika num2 lebih besar dari num1 , jika tidak kembalikan string false . Jika nilai parameter
sama satu sama lain maka kembalikan string -1 .
Contoh
Masukan: 3 & num2 = 122

Keluaran: benar

Keluaran: -1
LIHAT TANTANGAN
fungsi CheckNums(num1,num2) {
jika (bil1 == bilangan2) {

kembalikan "-1";
}
kalau tidak {
kembali (num2 > num1);
}
}

CheckNums(readline());
jika (bil2 > bilangan1) {
kembali benar;
} lain jika (num1 === num2) {
kembali '-1';
} kalau tidak {
kembali salah;
}

// kode di sini
if ((num1 - num2) < 0) return true;
lain jika ((num1 - num2) > 0) return false;
selain itu kembalikan -1;
}

Konversi Waktu
Minta fungsi TimeConvert( num ) ambil parameter num yang diteruskan dan kembalikan jumlah
jam dan menit yang diubah parameter menjadi ( mis. jika num = 63 maka hasilnya harus 1:3). Pisahkan
jumlah jam dan menit dengan titik dua.
Contoh
Masukan: 126
Keluaran: 2:6
Masukan: 45
Keluaran: 0:45
fungsi TimeConvert(num) {
var jam = Math.floor(num/60);
var menit = num % 60;
var str = jam + ":" + menit;
kembali str;
}
TimeConvert(readline());
biarkan jam = Math.floor(num/60);

biarkan menit = bil % 60;
kembali jam + ':' + menit;

// kode di sini
return Math.floor(num / 60) + ':' + (num % 60);

Sup alfabet
Miliki fungsi AlphabetSoup( str ) ambil parameter string str yang diteruskan dan kembalikan
string dengan huruf dalam urutan abjad ( mis. halo menjadi ehllo). Asumsikan angka dan simbol tanda
baca tidak akan disertakan dalam string.
Contoh
Keluaran: bcdeeorty
Masukan: "hooplah"
Keluaran: ahhloop
function AlphabetSoup(str) {
var array = str.split("");

var reversearrays = arrays.sort();
var hasil = reversearrays.join("");
mengembalikan hasil;

AlphabetSoup(readline());
biarkan huruf = str.split('');

return letters.sort().join('');

// kode di sini
kembali str.split('').sort(fungsi(ch1, ch2) {
kembalikan ch1.charCodeAt(0) - ch2.charCodeAt(0);
}).bergabung('');
}

Pemeriksaan AB
Mintalah fungsi ABCheck( str ) ambil parameter str yang diteruskan dan kembalikan string dengan
benar jika karakter a dan b dipisahkan tepat 3 tempat di mana pun dalam string setidaknya sekali ( yaitu
"jalur yang dipinjam" akan menghasilkan true karena ada tepat tiga karakter antara a dan b ). Kalau
tidak, kembalikan string salah.
Contoh
Masukan: "setelah buruk"

Keluaran: salah
Masukan: "Laura terisak"

Keluaran: benar
fungsi ABCheck(str) {
pat = /(a...b|b...a)/
return patt.test(str);

ABCheck(readline());
if (str.panjang < 5) {
kembali salah;
}
console.log(str.length);
for (biarkan i = 0; i < str.panjang-4; i++) {

// cari a
if (str[i] === 'a') {
if (str[i+4] === 'b') {
kembali benar;
}
}
if (str[i] === 'b') {

if (str[i+4] === 'a') {
kembali benar;
}
}
}
kembali salah;

// kode di sini
return str.match(/[aA].{3}[bB]/) !== null;

}

Hitung vokal
Miliki fungsi VowelCount( str ) ambil parameter string str yang diteruskan dan kembalikan
jumlah vokal yang dikandung string ( mis. "Semua sapi makan rumput dan moo" akan mengembalikan
8). Jangan menghitung y sebagai vokal untuk tantangan ini.
Contoh
Masukan: "halo"
Keluaran: 2
Keluaran: 3
fungsi Jumlah Vokal(str) {
var patt = /[aeiou]/gi;
var arr = str.cocok(patt);
jika (arr == nol) {

kembali 0;
}
kalau tidak {
return arr.panjang;
}
}

Hitung Vokal(garis baca());
biarkan vokal = 'aeiou';

biarkan hitung = 0;

if (vokal.termasuk(str[i])) {
hitung++;
}
}
}


// kode di sini
kembali str.split('').filter(fungsi(ch) {
kembalikan ['a', 'e', 'i', 'o', 'u'].indexOf(ch.toLowerCase()) > -1;
}).panjang;

Jumlah kata
Miliki fungsi WordCount( str ) ambil parameter string str yang diteruskan dan kembalikan jumlah
kata yang dikandung string ( misalnya "Jangan pernah makan gandum atau kue suwir" akan
mengembalikan 6). Kata-kata akan dipisahkan oleh spasi tunggal.
Contoh
Masukan: "Halo Dunia"

Keluaran: 2
Masukan: "satu 22 tiga"

Keluaran: 3
function Jumlah Kata(str) {
var arr = str.split(" ");
var jawaban = arr.panjang;
kembali jawaban;

WordCount(readline());

return str.split(' ').panjang;
}

// kode di sini
return str.split(' ').panjang;
}

Mantan Oh
Memiliki fungsi ExOh( str ) ambil parameter str yang diteruskan dan kembalikan string true jika
ada jumlah x dan o yang sama, jika tidak, kembalikan string false . Hanya dua huruf ini yang akan
dimasukkan dalam string, tanpa tanda baca atau angka. Sebagai contoh: jika str adalah "xooxxxxooxo"
maka hasilnya harus kembali salah karena ada 6 x dan 5 o.
Contoh
Masukan: "xooxxo"
Keluaran: benar
Masukan: "x"
Keluaran: salah
fungsi ExOh(str) {
var regExPatternX = /x/gi;
var regExPatternO = /o/gi;
var arrayXLen = str && str.cocok(regExPatternX) ?

str.match(regExPatternX).panjang : 0;
var arrayOLen = str && str.cocok(regExPatternO) ?
str.match(regExPatternO).panjang : 0;
kembali arrayXLen === arrayOLen;

}

ExOh(readline());
fungsi ExOh(str) {
biarkan xhitung = 0;
biarkan oHitung = 0;

jika (str[i] === 'x') {
xHitung++;
}
if (str[i] === 'o') {
o Hitung++;
}
}
kembali (xCount === oCount) ? benar salah;

ExOh(readline());
fungsi ExOh(str) {
// kode di sini
var huruf = str.split('');
var numOfEx = huruf.filter(fungsi(ch) {
return ch === 'x';
}).panjang;
var numOfOh = huruf.filter(fungsi(ch) {
return ch === 'o';
}).panjang;
kembalikan numOfEx === numOfOh;

ExOh(readline());
Palindrom
Miliki fungsi Palindrome( str ) ambil parameter str yang diteruskan dan kembalikan string true
jika parameternya adalah palindrome, (stringnya maju sama seperti mundur) jika tidak, kembalikan
string false . Misalnya: "mobil balap" juga "mobil balap" mundur. Tanda baca dan angka tidak akan
menjadi bagian dari string.
Contoh
Input: "tidak pernah ganjil atau genap"

Keluaran: benar
Masukan: "mata"
Keluaran: benar
fungsi Palindrom(str) {
dimodifikasi = str.replace(/W/g,"");
var arr1 = dimodifikasi.split("");

var arr2 = arr1;
arr2 = arr2.mundur();
str2 = arr2.bergabung("");
kembali dimodifikasi == str2;

Palindrom(garis baca());
str = str.ganti(/ /g, '');
for (biarkan i = 0, max = Math.floor(str.length/2); i < max; i++) {

if (str[i] !== str[str.panjang-1-i]) {
kembali salah;
}
}
kembali benar;

str = str.ganti(/ /g, '');

kembali salah;
}
}
kembali benar;

Arith Geo
Miliki fungsi ArithGeo( arr ) ambil larik angka yang disimpan di arr dan kembalikan string
"Aritmatika" jika urutannya mengikuti pola aritmatika atau kembalikan "Geometris" jika mengikuti
pola geometris. Jika urutan tidak mengikuti salah satu pola, kembalikan -1 . Barisan aritmatika adalah
barisan yang selisih antara setiap bilangan tetap, sedangkan dalam barisan geometri, setiap suku setelah
suku pertama dikalikan dengan rasio konstan atau umum. Contoh aritmatika: [2, 4, 6, 8] dan Contoh
geometri: [2, 6, 18, 54]. Angka negatif dapat dimasukkan sebagai parameter, 0 tidak akan dimasukkan,
dan tidak ada larik yang berisi semua elemen yang sama.
Contoh
Masukan: [5,10,15]
Keluaran: Aritmatika
Masukan: [2,4,16,24]
Keluaran: -1
fungsi ArithGeo(arr) {
var len = arr.panjang;
var arithK = arr[1] - arr[0];
var geoK = arr[1] / arr[0];
untuk (var i = 0; i < len - 1; i++) {

jika (arr[i+1] - arr [i] !== aritK) {
merusak;
}
lain jika (i === len - 2) {
kembalikan "Aritmatika";
}
}
untuk (var i = 0; i < len - 1; i++) {

if (arr[i+1] / arr [i] !== geoK) {
merusak;
}
lain jika (i === len - 2) {
kembalikan "Geometris";
}
}
kembali -1;
}

ArithGeo(garis baca());
biarkan aritmatika = benar;

// uji aritmatika
for (biarkan i = 2, diff = arr[1] - arr[0]; i < arr.length; i++) {
jika (arr[i] - arr[i-1] !== diff) {
aritmatika = salah;
}
}
jika (aritmatika) {
mengembalikan 'Aritmatika';
}
biarkan geometris = benar;

// geometris
for (biarkan i = 2, pembagi = arr[1] / arr[0]; i < arr.length; i++) {
if (arr[i] / arr[i-1] !== pembagi) {
geometris = salah;
}
}
jika (geometris) {
kembali 'Geometris';
}
kembali -1;

// kode di sini
var isArith = function(arr) {
if (arr.panjang < 2) return -1;
var perbedaan = arr[1] - arr[0];
untuk (var i = 1; i < arr.panjang - 1; i++) {
if (arr[i + 1] - arr[i] !== perbedaan) return false;
}
kembali benar;
};
var isGeo = function(arr) {

var pengali = arr[1] / arr[0];
if (arr[i + 1] / arr[i] !== multiplier) return false;
}
kembali benar;
};
if (isArith(arr)) kembalikan "Aritmatika";

else if (isGeo(arr)) return "Geometris";
selain itu kembalikan -1;
}

Penambahan ArrayI
Miliki fungsi ArrayAdditionI( arr ) ambil larik angka yang disimpan dalam arr dan kembalikan
string benar jika ada kombinasi angka dalam larik (tidak termasuk angka terbesar) dapat ditambahkan
hingga sama dengan angka terbesar dalam larik, jika tidak kembalikan string salah . Sebagai contoh:
jika arr berisi [4, 6, 23, 10, 1, 3] keluaran harus benar karena 4 + 6 + 10 + 3 = 23. Larik tidak akan
kosong, tidak akan berisi semua elemen yang sama, dan mungkin berisi angka negatif.
Contoh
Masukan: [5,7,16,1,2]
Keluaran: salah
Masukan: [3,5,-1,8,12]
Keluaran: benar
function ArrayAdditionI(arr) {
target var;
var addArr = arrayPrep(arr);
var len = addArr.panjang;
var permNum = Math.pow(2, len);
console.log('test0 ', permNum, target, addArr);
for(var i = 0; i <= permNum; i++) {

permStr = (i).toString(2);
strlen = permStr.panjang;
penghitung var = 0;
untuk(var j = 0; j < strlen; j++) {
jika(permStr[j] === '1') {
penghitung += addArr[j];
}
}
if (penghitung === target) {
kembali benar
}
}
kembali salah
fungsi arrayPrep(arr2) {
arr.sort(fungsi(a, b){
kembali a - b
});
target = arr2.pop()
kembali arr2
}
}
ArrayAdditionI(readline());
// temukan angka terbesar

biarkan Indeks terbesar = 0;
biarkan bilangan terbesar = 0;
for (biarkan i = 0; i < arr.length; i++) {
if (arr[i] > bilangan terbesar) {
indeks terbesar = i;
bilangan terbesar = arr[i];
}
}
arr.splice(largestIndex, 1);
biarkan kombo = [];

biarkan ukuran = arr.panjang;
for (biarkan i = 0, max = Math.pow(2, size); i < max; i++) {

biarkan num = i.toString(2);
while (num.panjang < ukuran) {
bilangan = '0' + bilangan;
}
combos.push(bil);
}
// ulangi semua kombo angka

for (biarkan i = 0; i < combos.length; i++) {
biarkan jumlah = 0;
for (biarkan j = 0; j < kombo[i].panjang; j++) {
if (kombo[i][j] === '1') {
jumlah += arr[j];
}
}
if (jumlah === bilangan terbesar) {

kembali benar;
}
}
kembali salah;
}

// kode di sini
var sortArr = arr.sort(fungsi(a,b) {return ab;});
var terbesar = sortArr.pop();
var jumlah = [];
untuk (i = 0; i < Math.pow(2, sortArr.panjang); i++) {

jumlah var = 0;
var bitMask = i.toString(2).split('');
while (bitMask.panjang < sortArr.panjang) {

bitMask.unshift('0');
}
for (j = 0; j < bitMask.panjang; j++) {

if (bitMask[j] === '1') {
jumlah += sortArr[j];
}
}
jumlah.push(jumlah);
}
return sums.indexOf(largest) !== -1;

}

Jumlah Surat I
Mintalah fungsi LetterCountI( str ) ambil parameter str yang diteruskan dan kembalikan kata
pertama dengan jumlah huruf berulang terbanyak. Misalnya: "Hari ini, adalah hari terbesar yang pernah
ada!" harus mengembalikan terbesar karena memiliki 2 e (dan 2 t) dan datang sebelumnya yang juga
memiliki 2 e. Jika tidak ada kata dengan huruf berulang, kembalikan -1 . Kata-kata akan dipisahkan oleh
spasi.
Contoh
Input: "Halo pai apel"

Keluaran: Halo
Masukan: "Tidak ada kata"

Keluaran: -1
function Jumlah HurufI(str) {
var arr = str.toLowerCase().split(" ");
var n = arr.panjang;
penghitung var = 1;
var jumlah maksimum = 0;
var newarr = [];
untuk (var i = 0; i < n; i++) {

kataarr = arr[i].split("");
wordarr.sort();
for (var j = 0; j < wordarr.panjang; j++) {

if (kataarr[j] == kataarr[j+1]) {
penghitung++;
}
kalau tidak {
if (penghitung > jumlah maksimum) {
maxcount = penghitung;
penghitung = 1;
}
}
}
newarr.push([arr[i], jumlah maksimum])
jumlah maksimum = 0;
}
newarr.sort(function(a, b) {return b[1] - a[1]});
if (baru[0][1] == 1) {
kembali -1;
}
kalau tidak {
return newarr[0][0];
}
}

LetterCountI(readline());
biarkan kata = str.split(' ');
biarkan bestCount = 0;
biarkan kataterbaik = '';
for (biarkan i = 0; i < panjang kata; i++) {

biarkan jumlah huruf = [];
biarkan Hitungan terbesar = 0;
for (biarkan j = 0; j < kata[i].panjang; j++) {
hurufHitung[kata[i][j]] = (Jumlahhuruf[kata[i][j]] === tidak terdefinisi)
? 1 : ++jumlahhuruf[kata[i][j]];
if (Hitunghuruf[kata[i][j]] >= 2 &&Hitunghuruf[kata[i][j]]
>Hitungterbesar) {
hitungterbesar = hitunghuruf[kata[i][j]];
}
}
if (Penghitunganterbesar > Penghitunganterbaik) {

hitungterbaik = hitungterbesar;
kataterbaik = kata[i];
}
}
kembali (bestWord === '') ? -1 : kata terbaik;

// kode di sini
var kata = str.replace(/[Â-Za-zs]/g, '').split(/s+/);
var hitungan = kata.peta(fungsi(kata) {

kata = kata.toLowerCase();
var huruf = [];
untuk (huruf kata) {
if (huruf[huruf]) {
huruf[huruf] += 1;
} kalau tidak {
huruf[huruf] = 1;
}
}
surat balasan;
});
var greatestCounts = jumlah.peta(fungsi(kata) {

var terbesar = 0;
untuk (huruf dalam kata) {
if (kata[huruf] > terbesar) {
terbesar = kata[huruf];
}
}
kembali terbesar;
});
var terbesar = Math.max.apply(null, greatestCounts);

if (terbesar <= 1) return -1;
kembali kata-kata[terbesarCounts.indexOf(terbesar)];
}

GreatLow Kedua
Miliki fungsi SecondGreatLow( arr ) ambil larik angka yang disimpan di arr dan kembalikan
angka terendah kedua dan terbesar kedua, masing-masing, dipisahkan oleh spasi. Misalnya: jika arr
berisi [7, 7, 12, 98, 106] hasilnya harus 12 98 . Larik tidak akan kosong dan akan berisi setidaknya 2
angka. Ini bisa menjadi rumit jika hanya ada dua angka!
Contoh
Masukan: [1, 42, 42, 180]

Keluaran: 42 42
Masukan: [4, 90]

Keluaran: 90 4
fungsi SecondGreatLow(arr) {
arr.sort(fungsi(a, b) {kembalikan a - b});
arr = kesepian(arr);
var newlen = arr.panjang;
return arr[1] + ' ' + arr[newlen - 2]
fungsi kesepian(arr) {
var len = arr.panjang;
var testobj = {};
var keluaran = [];
jumlah var = 0;
var pemegang = arr[i];
if (!testobj[pemegang]) {
testobj[pemegang] = true;
keluaran[hitung++] = pemegang;
}
}
keluaran kembali
}
}

SecondGreatLow(readline())
arr = arr.slice().sort((a, b) => a - b);
biarkan detik = arr[1];

jika (arr[i] !== arr[0]) {
detik = arr[i];
merusak;
}
}
biarkan kedua dari belakang = arr[arr.panjang - 2];

for (biarkan i = arr.panjang - 2; i >= 0; i--) {
if (arr[i] !== arr[arr.panjang - 1]) {
kedua dari belakang = arr[i];
merusak;
}
}
return detik + ' ' + kedua dari belakang;

SecondGreatLow(readline());
// kode di sini
var diurutkan = arr.sort(fungsi(a,b){return ab;});
var terbesar = diurutkan[diurutkan.panjang - 1];
var terendah = diurutkan[0];
var detikTerbesar, detikTerendah;
for (var i = 0; i < diurutkan.panjang; i++) {

if (sorted[i] !== terendah) {
detikTerendah = diurutkan[i];
merusak;
}
}
for (var i = sort.length - 1; i >= 0; i--) {

if (sorted[i] !== terbesar) {
secondTerbesar = diurutkan[i];
merusak;
}
}
return detikTerendah + " " + detikTerbesar;

}

SecondGreatLow(readline());
Divisi Dirangkai
Miliki fungsi DivisionStringified( num1 , num2 ) ambil kedua parameter yang diteruskan,
bagi num1 dengan num2 , dan kembalikan hasilnya sebagai string dengan koma yang diformat dengan
benar. Jika jawaban hanya terdiri dari 3 digit, kembalikan angka tanpa koma ( mis. 2/3 harus
menghasilkan "1"). Misalnya: jika num1 adalah 123456789 dan num2 adalah 10000 , hasilnya harus
"12,346" .
Contoh

Keluaran: 3

Keluaran: 103
LIHAT TANTANGAN
fungsi DivisiStringified(num1,num2) {
var res = Math.round(num1/num2);

var string = res.toString();
var numleng = string.panjang;
var string baru = string;
if (numleng > 3) {
var arr = string.split("");
for (var i= numleng - 3; i > 0; i = i - 3) {
arr.splice(i, 0, ",");
}
var string baru = arr.join("");
}
mengembalikan string baru;

DivisionStringified(readline());
biarkan quotientString = Math.round(num1 / num2).toString();
biarkan temp = quotientString.split('').reverse();

for (biarkan i = 0; i < temp.length; i++) {
if (i % 3 === 2 && i != temp.length-1) { // selanjutnya butuh koma
stringbaru = ',' + temp[i] + stringbaru;
} kalau tidak {
stringbaru = temp[i] + stringbaru;
}
}
//console.log(newString);
}

// kode di sini
var format = fungsi(bil) {
var hasil = '';
var keseluruhan = Math.round(num);
jika (seluruh === 0) kembalikan 0;
while (seluruh > 0) {

hasil = (hasil === '' ? '' : ',') + hasil;
hasil = (seluruh % 1000) + hasil;
keseluruhan = Math.floor(keseluruhan / 1000);
}
}
format pengembalian(num1 / num2);

}

Menghitung Menit I
Miliki fungsi CountingMinutesI( str ) ambil parameter str yang akan diteruskan dua kali
(masing-masing diformat dengan benar dengan titik dua dan am atau pm) dipisahkan oleh tanda hubung
dan kembalikan jumlah total menit antara dua kali. Waktu akan menggunakan format jam 12 jam.
Misalnya: jika str adalah 9:00-10:00 maka hasilnya harus 60 . Jika str adalah 13:00-11:00, hasilnya
harus 1320 .
Contoh
Masukan: "12:30 siang-12:00 pagi"

Keluaran: 690
Masukan: "01:23-01:08"
Keluaran: 1425
Solusi Menghitung Menit I
JAVASCRIPT
LIHAT TANTANGAN
function CountingMinutesI(str) {
var seps = str.split("-");
var col1 = seps[0].indexOf(":");
var col2 = seps[1].indexOf(":");
var jam1 = parseInt(seps [0].slice(0, col1));
var jam2 = parseInt(seps[1].slice(0, col2));
var min1 = parseInt(seps[0].slice(col1+1, col1+3));
var min2 = parseInt(seps[1].slice(col2+1, col2+3));
var ampm1 = seps[0].slice(-2);
var ampm2 = seps[1].slice(-2);
if (ampm1 == "pm" && jam1 != 12) {
jam1 = jam1 + 12;
}
if (ampm2 == "pm" && jam2 != 12) {
jam2 = jam2 + 12;
}
if (jam1 == 12 && ampm1 == "pagi") {
jam1 = 0;
}
if (jam2 == 12 && ampm2 == "pagi") {
jam2 = 0;
}
var waktu1 = (jam1*60) + menit1;
var waktu2 = (jam2*60) + menit2;
var diff = waktu2 - waktu1;
jika (beda < 0) {

perbedaan = perbedaan + (60 * 24);
}
kembali berbeda;

CountingMinutesI(readline());
biarkan kali = str.split('-');
times = times.map(function(currentValue, index, array){

biarkan pasangan = currentValue.split(':');
biarkan waktu = ((pairs[1][2] === 'a') ? parseInt(pairs[0]) % 12 :
parseInt(pairs[0]) % 12 + 12) * 60 + parseInt(pairs[1 ][0] + pasangan[1][1]);
waktu kembali;
});
let diff = kali[1] - kali[0];

kembali (beda < 0) ? beda + 1440 : beda;
}
// kode di sini
var kali = str.split('-');
var dari = kali[0], ke = kali[1];
fungsi parseMinutes(timeStr) {
var waktu = timeStr.match(/d+/g);
var jam = parseInt(waktu[0]), menit = parseInt(waktu[1]);
var ampm = (timeStr.match(/[a|p]m/g)[0] === 'am') ? 0 : 1;
if (jam === 12) jam = 0;
return (jam + ampm * 12) * 60 + menit;

}
var fromMinutes = parseMinutes(dari), toMinutes = parseMinutes(ke);

var perbedaan = toMinutes - fromMinutes;
var oneDayInMinutes = 24 * 60;
kembali (selisih < 0) ? oneDayInMinutes + perbedaan : perbedaan;

}

Modus Berarti
Miliki fungsi MeanMode( arr ) ambil larik angka yang disimpan dalam arr dan kembalikan 1 jika
mode sama dengan mean , 0 jika tidak sama satu sama lain ( mis. [5, 3, 3, 3, 1] harus mengembalikan 1
karena modus (3) sama dengan mean (3)). Larik tidak akan kosong, hanya akan berisi bilangan bulat
positif, dan tidak akan berisi lebih dari satu mode.
Contoh
Masukan: [1, 2, 3]
Keluaran: 0
Masukan: [4, 4, 4, 6, 2]
Keluaran: 1
function MeanMode(arr) {
len = arr.panjang
//Langkah 1: tentukan rata-rata - cukup jelas
fungsi mean(arr) {
jumlah var = 0;
hitung += arr[i]
}
console.log (hitung / len)
kembali hitungan / len
}
//Langkah 2: tentukan modusnya. Kita perlu menghitung berapa banyak dari setiap
tipe yang ada di dalam array. Salah satu alternatifnya adalah menjaga penghitung
tetap berjalan, mengurutkan larik, lalu menghitung hingga item berubah, melacak
jumlah maksimum dan nilai asosiasi. Berikut ini adalah cara yang jauh lebih mudah,
dengan asumsi bahwa seseorang memiliki keakraban dasar dengan objek javascript. Itu
membuat setiap entri baru menjadi kunci, dan menghitung berapa banyak dari masing-
masing entri yang ada, lalu membuat larik dari pasangan nilai kunci yang dibuat.
mode fungsi(arr) {
var obj = {};
for (var i = 0, len = arr.panjang; i < len; i++) {
if (obj[arr[i]] === tidak terdefinisi) {
obj[arr[i]] = 1;
}
kalau tidak {
obj[arr[i]]++;
}
}
var objarr = [];
untuk (x dalam obj) {
objarr.push([x, obj[x]]);
}
objarr.sort(fungsi(a, b) {return b[1] - a[1]});
console.log(objarr[0][0]);
return objarr[0][0];
}
//Bandingkan rata-rata dan modus
mode pengembalian(arr) == mean(arr)? 1: 0;
}

MeanMode(readline());
// Temukan mode
biarkan kebanyakanKejadian = 0;
biarkan mode = 0;
biarkan marco = arr[i];
for (misalkan j = i+1, count = 0; j < arr.length; j++) {
if (marco === arr[j]) {
// cocok!
hitung++;
if (hitung > kebanyakan kejadian) {
kebanyakanKejadian = hitung;
modus = arr[j];
}
}
}
}
// Temukan rata-rata
misalkan = 0;
rata-rata += arr[i];
}
rata-rata = Matematika.bulat(rata-rata/arr.panjang);
kembali (berarti === mode) ? 1 : 0;

// kode di sini
mode fungsi(arr) {
var hitungan = [], mode, maxCount = 0;
untuk (jumlah arr) {
bilangan = bilangan + ' ';
if (jumlah[jumlah]) jumlah[jumlah]++;
selain itu jumlah[jumlah] = 1;
}
untuk (jumlah dalam hitungan) {

if (jumlah[jumlah] > 1 && jumlah[jumlah] > jumlahmaks) {
mode = parseInt(bil);
maxCount = jumlah[jumlah];
}
}
modus kembali;
}
fungsi mean(arr) {
return arr.reduce(function(a,b) {return a+b;}, 0) / arr.length;
}
mode pengembalian(arr) === maksud(arr) ? 1 : 0;

}

Sisipan Dash
Miliki fungsi DashInsert( str ) sisipkan tanda hubung ('-') di antara masing-masing dua angka
ganjil di str . Sebagai contoh: jika str adalah 454793 outputnya harus 4547-9-3 . Jangan menghitung
nol sebagai angka ganjil.
Contoh
Masukan: 99946
Keluaran: 9-9-946
Masukan: 56730
Keluaran: 567-30
fungsi DashInsert(num) {
var strnum = num.toString();
var arr = strnum.split("");
for (i = 0; i < arr.panjang; i++) {

arr[i] = parseInt(arr[i]);
}
untuk (i = 0; i < arr.panjang - 1; i++) {

jika (arr[i]%2 == 1 && arr[i + 1]%2 == 1) {
arr.splice(i+1, 0, "-");
}
}
x = arr.bergabung("");
kembali x;

DashInsert(readline());
fungsi DashInsert(str) {
biarkan newString = str[0];
for (biarkan i = 1, lastOdd = str[0] % 2; i < str.length; i++) {

if (str[i] % 2 === 1 && lastOdd === 1) {
stringbaru += '-' + str[i];
} kalau tidak {
}
lastOdd = str[i] % 2;
}
}

fungsi DashInsert(str) {
// kode di sini
var digit = str.split('');
fungsi isOdd(n) {
kembalikan parseInt(n) % 2 === 1;
}
for (var i = 0; i < digits.length - 1; i++) {

if ( isOdd(digit[i]) && isOdd(digit[i+1]) ) {
digit.splice(i + 1, 0, '-');
saya++;
}
}
kembali angka.bergabung('');
}

Tukar Kasus
Miliki fungsi SwapCase( str ) ambil parameter str dan tukar case dari setiap karakter. Sebagai
contoh: jika str adalah "Hello World", keluarannya adalah hELLO WORLD . Biarkan angka dan
simbol tetap seperti apa adanya.
Contoh
Masukan: "Halo-LOL"
Keluaran: halo-lol
Masukan: "Sup DUDE!!?"

Keluaran: sUP Bung!!?
fungsi SwapCase(str) {
arr = str.split("");
for (var i = 0; i < arr.length; i++) {
if (arr[i] == arr[i].toUpperCase()) {
arr[i] = arr[i].toLowerCase();
}
lain jika (arr[i] == arr[i].toLowerCase()) {
arr[i] = arr[i].toUpperCase();
}
}
str = arr.join("");
kembali str;

SwapCase(readline());
const RENDAH = 'abcdefghijklmnopqrstuvwxyz';

const ATAS = 'ABCDEFGHIJKLMNOPWRSTUVWXYZ';

if (RENDAH.termasuk(str[i])) {
stringbaru += str[i].toUpperCase();
} else if (UPPER.includes(str[i])) {
stringbaru += str[i].toLowerCase();
} kalau tidak {
}
}
}

// kode di sini
return str.split('').peta(fungsi(huruf) {
if (huruf === huruf.toLowerCase()) kembalikan huruf.toUpperCase();
lain jika (huruf === letter.toUpperCase()) return letter.toLowerCase();
lain surat balasan;
}).bergabung('');
}

Penambahan Angka
Minta fungsi NumberSearch( str ) ambil parameter str , cari semua angka dalam string,
tambahkan semuanya, lalu kembalikan angka terakhir itu. Contoh: jika str adalah "88Hello 3World!"
outputnya harus 91 . Anda harus membedakan antara angka satu digit dan angka multi digit seperti pada
contoh di atas. Jadi "55Halo" dan "5Halo 5" harus mengembalikan dua jawaban yang berbeda. Setiap
string akan berisi setidaknya satu huruf atau simbol.
Contoh
Masukan: "75Number9"
Keluaran: 84
Masukan: "10 2Satu Angka*1*"

Keluaran: 13
LIHAT TANTANGAN
fungsi Penambahan Angka(str) {
jumlah var = 0;
jumlah var = 0;
var strArr = fungsi(str) {
//keluarkan non-digit dan ganti dengan spasi agar tetap terpisah
str = str.ganti(/[^0-9]/g, ' ');
// lepas spasi sebelumnya atau terakhir
str = str.trim();
// ubah spasi ganda apa pun menjadi spasi tunggal, hingga tidak ada lagi
spasi ganda yang tersisa
while (str.indexOf(' ') !== -1) {
str = str.ganti(/ss/g, ' ');
}
// mengembalikan array string angka tanpa spasi;
return str.split(' ');
}
//panggil fungsi strArr pada input pengguna dan simpan sebagai "disiapkan"
var disiapkan = strArr(str);
// ubah setiap string angka menjadi angka
prepped = prepped.map(function(val) {
kembali val? parseInt(val): 0;
})
console.log( 'preppedmap', prepped);
// jalankan metode pengurangan untuk menjumlahkan semua angka
var ans = prepped.reduce(function(firstval, lastval){
mengembalikan nilai pertama + nilai terakhir
})
kembali ans
}

NumberAddition(readline());
biarkan DIGITS = '0123456789';

biarkan angka = [];
// Pertama temukan angka

for (biarkan i = 0, number = ''; i < str.length; i++) {
if (!DIGITS.includes(str[i])) {
jika (angka !== '') {
angka.push(angka);
}
angka = '';
} kalau tidak {
angka += str[i];
// kasus khusus untuk karakter terakhir

if (i === str.panjang-1) {
angka.push(angka);
}
}
}
biarkan jumlah = 0;
for (biarkan i = 0; i < angka.panjang; i++) {
jumlah += parseInt(angka[i]);
}
}


var angka = str.cocok(/\d+/g) || [];
kembalikan angka.kurangi(fungsi(jumlah, angka) {jumlah kembalian + Angka(angka)},
0);
}

Terbesar Ketiga
Miliki fungsi ThirdGreatest( strArr ) ambil array string yang disimpan di strArr dan
kembalikan kata terbesar ketiga di dalamnya. Jadi misalnya: jika strArr adalah ["halo", "dunia",
"sebelum", "semua"] output Anda harus dunia karena "sebelum" panjangnya 6 huruf, dan "halo" dan
"dunia" keduanya 5, tetapi hasilnya harus dunia karena muncul sebagai kata 5 huruf terakhir dalam
larik. Jika strArr adalah ["halo", "dunia", "setelah", "semua"] output harus setelah karena tiga kata
pertama semuanya terdiri dari 5 huruf, jadi kembalikan yang terakhir. Array akan memiliki setidaknya
tiga string dan setiap string hanya akan berisi huruf.
Contoh
Masukan: ["coder", "byte", "code"]

Keluaran: kode
Masukan: ["abc","defg","z","hijk"]
Keluaran: abc
function ThirdGreatest(strArr) {
strArr.sort(function(a, b) {return b.length - a.length});
return strArr[2];
}

KetigaTerbesar(readline());
strArr.sort(function(a,b){return b.length - a.length});
return strArr[2];

// kode di sini
return strArr.sort(fungsi(a, b) {
kembali (b.panjang - a.panjang);
})[2];

Kekuatan Dua
Minta fungsi PowersofTwo( num ) ambil parameter num yang diteruskan yang akan menjadi
bilangan bulat dan kembalikan string benar jika pangkat dua. Jika tidak mengembalikan string false .
Misalnya jika inputnya adalah 16 maka program Anda harus mengembalikan string yang benar tetapi
jika inputnya adalah 22 maka outputnya harus berupa string false.
Contoh
Masukan: 4
Keluaran: benar
Masukan: 124
Keluaran: salah
function PowersofTwo(num) {
jika (bil < 2){

ans = "salah";
}
kalau tidak {
while (bil >= 2){
uji var = num%2;
jika (tes == 0){
bilangan = bilangan/2
ans = "benar";}
kalau tidak{
bilangan = 0;
ans = "salah"}
}
}
// kode di sini
kembali dan;

PowersofTwo(readline());
return Number.isInteger(Math.log(num) / Math.log(2)) ? benar salah;
}
// kode di sini
if (num === 1) return true;
kalau tidak {
kembali (num % 2 === 0) ? PowersofTwo(num / 2) : false;
}
}

Ketahanan Aditif
Apakah fungsi AdditivePersistence( num ) mengambil parameter num yang akan selalu berupa
bilangan bulat positif dan mengembalikan kegigihan aditifnya yang merupakan berapa kali Anda harus
menambahkan digit dalam num hingga Anda mencapai satu digit. Sebagai contoh: jika num adalah 2718
maka program Anda harus mengembalikan 2 karena 2 + 7 + 1 + 8 = 18 dan 1 + 8 = 9 dan Anda berhenti
di 9.
Contoh
Masukan: 4
Keluaran: 0
Masukan: 19
Keluaran: 2
LIHAT TANTANGAN
fungsi AdditivePersistence(num) {
function arrprep(mati rasa) {

var numstr = mati rasa.toString();
var arr = numstr.split('');
var angkar = arr.peta(fungsi(val) {
kembalikan parseInt(val)
})
mengembalikan angka
}
penambahan fungsi(arr) {
var redux = arr.reduce(fungsi(a, b){
kembalikan a + b})
mengembalikan redux
}
jumlah var = 0;
while (bil > 9) {

num = penjumlahan(arrprep(bil));
hitung++;
}
menghitung pengembalian

AdditivePersistence(readline());
num = num.toString();
biarkan hitung = 0;
while (hitung < 10000) { // hard stop

if (num.panjang === 1) {
merusak;
}
hitung++;
biarkan jumlah = 0;
for (biarkan i = 0; i < num.length; i++) {
jumlah += parseInt(bil[i]);
}
num = jumlah.toString();
}
}

// kode di sini
fungsi addDigits(num) {
kembalikan num.toString().split('').map(function(num) {
kembalikan parseInt(bil);
}).mengurangi(fungsi(a, b) {mengembalikan a + b;}, 0);
}
var hasil = bil;

jumlah var = 0;
while (hasil > 9) {
hasil = tambahDigit(hasil);
hitung++;
}
}

Kegigihan Multiplikatif
Miliki fungsi MultiplicativePersistence( num ) ambil parameter num yang diteruskan yang
akan selalu berupa bilangan bulat positif dan kembalikan kegigihan perkaliannya yang merupakan
berapa kali Anda harus mengalikan digit dalam num hingga Anda mencapai satu digit. Misalnya: jika
num adalah 39 maka program Anda harus mengembalikan 3 karena 3 * 9 = 27 lalu 2 * 7 = 14 dan
terakhir 1 * 4 = 4 dan Anda berhenti di 4.
Contoh
Masukan: 4
Keluaran: 0
Masukan: 25
Keluaran: 2
function MultiplicativePersistence(num) {
fungsi numprep(bil) {
var strnum = num.toString();
var arr = strnum.split('');
var angkar = arr.peta(fungsi(val) {
return parseInt(val)});
mengembalikan angka
}
function mulnums(arr) {
var newnum = arr.reduce(fungsi(a, b) {
mengembalikan a * b})
mengembalikan nomor baru
}
// kode di sini
jumlah var = 0;
while (bil > 9) {

num = multnum(numprep(num));
menghitung++
}
menghitung pengembalian
}

MultiplicativePersistence(readline());
biarkan hitung = 0;
sementara(1) {
if (num.panjang === 1) {
merusak;
}
hitung++;
misalkan jumlah = 1;
jumlah *= parseInt(bil[i]);
}
num = jumlah.toString();
}

// kode di sini
fungsi perkalianDigit(bil) {
kembalikan num.toString().split('').map(function(num) {
kembalikan parseInt(bil);
}).mengurangi(fungsi(a, b) {mengembalikan a * b;}, 1);
}
var hasil = bil;

jumlah var = 0;
while (hasil > 9) {
result = perkalianDigit(hasil);
hitung++;
}
}

Minimal Offline
Miliki fungsi OffLineMinimum( strArr ) ambil parameter strArr yang akan diteruskan yang
akan menjadi larik bilangan bulat mulai dari 1...n dan huruf "E" dan kembalikan subset yang benar
berdasarkan aturan berikut. Inputnya akan dalam format berikut: ["I", "I", "E", "I",...,"E",...,"I"] di mana
I berdiri untuk bilangan bulat dan E berarti mengeluarkan bilangan bulat terkecil saat ini di seluruh
rangkaian. Setelah selesai, program Anda harus mengembalikan set baru itu dengan bilangan bulat yang
dipisahkan dengan koma. Sebagai contoh: jika strArr adalah ["5","4","6","E","1","7","E","E","3","2"]
maka program Anda harus mengembalikan 4,1,5 .
Contoh
Masukan: ["1","2","E","E","3"]
Keluaran: 1,2
Masukan: ["4","E","1","E","2","E","3","E"]
Keluaran: 4,1,2,3
function OffLineMinimum(strArr) {
var len = strArr.panjang;
jumlah var = 0;
var holdArr = [];
var ans = [];
for(var i = 0; i < len; i++) {

if (strArr[hitung] === "E") {
var headArr = strArr.splice(0, hitung);
strArr.shift();
holdArr = holdArr.concat(headArr);
holdArr.sort(function(a, b) {return a - b});
ans.push(holdArr.shift());
hitungan = 0;
}
kalau tidak {
hitung++;
}
}
kembali ans.bergabung(',');
}

OffLineMinimum(readline());
biarkan hasil = [];

for (biarkan i = 0; i < strArr.panjang; i++) {
if (strArr[i] === 'E') {
result.push(removeSmallest(strArr, i));
} else if (strArr[i] === 'R') {
// tidak melakukan apapun
} kalau tidak {
// nomor tidak melakukan apa-apa
}
}
function removeSmallest(strArr, maxIndex) {
biarkan indeks terkecil = 0;

biarkan bilangan terkecil = null;
strArr.forEach(fungsi(nilai,indeks){
if (indeks > indeksmaks) {
kembali;
}
if (nilai !== 'E' && nilai !== 'R') {
if (bilanganterkecil === null || parseInt(nilai) <bilanganterkecil) {
indeksterkecil = indeks;
bilangan terkecil = parseInt(nilai);
}
}
});
strArr[smallestIndex] = 'R';
kembalikan angka terkecil;
}
kembalikan result.join(',');

// kode di sini
var arr = [], hasil = [];
var log = "";
untuk (item strArr) {
if (item === 'E') {
result.push(arr.shift());
} kalau tidak {
arr.push(parseInt(item));
arr = arr.sort(fungsi(a, b) {kembalikan a - b});
}
}
kembalikan result.join(',');
}

Mengubah Urutan
Miliki fungsi ChangingSequence( arr ) ambil larik angka yang disimpan di arr dan kembalikan
indeks di mana angka berhenti meningkat dan mulai menurun atau berhenti menurun dan mulai
meningkat. Sebagai contoh: jika arr adalah [1, 2, 4, 6, 4, 3, 1] maka program Anda harus
mengembalikan 3 karena 6 adalah titik terakhir dalam larik di mana angka bertambah dan angka
berikutnya memulai urutan menurun. Array akan berisi setidaknya 3 angka dan mungkin hanya berisi
satu urutan, naik atau turun. Jika hanya ada satu urutan dalam larik, maka program Anda harus
mengembalikan -1 . Pengindeksan harus dimulai dengan 0.
Contoh
Masukan: [-4, -2, 9, 10]

Keluaran: -1
Masukan: [5, 4, 3, 2, 10, 11]

Keluaran: 3
function ChangingSequence(arr) {
// pertama, tentukan apakah itu urutan naik atau turun
tipe var = arr[1] - arr[0] > 0 ? 'meningkat' : 'menurun';
// atur indeks maksimum array, agar tidak meluap

var maxInd = arr.panjang - 1;
// kode untuk array yang meningkat

if (ketik === 'meningkat') {
//findIndex adalah metode iterasi array yang disertakan dengan ES6. Itu
kembali
// nilai pertama yang dikembalikan oleh callback false.
var indeks = arr.findIndex(fungsi(val, ind) {
while (ind < maxInd) {
return val > arr[ind + 1];
}
kembali salah;
});
indeks pengembalian;
}
if (ketik === 'menurun') {

var indeks = arr.findIndex(fungsi(val, ind) {
while (ind < maxInd) {
return val < arr[ind + 1]
}
kembali 0;
});
indeks pengembalian;
}
}

ChangingSequence(readline());
biarkan indeks = null;

biarkan mode = (arr[1] - arr[0] > 0) ? benar salah;
if (arr[i] - arr[i-1] > 0 !== mode) {
indeks = i-1;
merusak;
}
}
kembali (indeks === null) ? -1 : indeks;
}

var meningkat = arr[0] < arr[1];

jika (meningkat) {
jika (arr[i] > arr[i + 1]) kembalikan saya;
} kalau tidak {
jika (arr[i] < arr[i + 1]) kembalikan saya;
}
}
kembali -1;
}

Rentang Tumpang Tindih
Miliki fungsi OverlappingRanges( arr ) ambil larik angka yang disimpan dalam arr yang akan
berisi 5 bilangan bulat positif, dua yang pertama mewakili rentang angka (a hingga b), 2 berikutnya juga
mewakili rentang bilangan bulat lainnya (c hingga d) , dan elemen ke-5 terakhir (x) yang juga akan
menjadi bilangan bulat positif, dan mengembalikan string yang benar jika kedua rangkaian rentang
tumpang tindih dengan setidaknya x angka. Sebagai contoh: jika arr adalah [4, 10, 2, 6, 3] maka
program Anda harus mengembalikan string true . Rentang angka pertama adalah 4, 5, 6, 7, 8, 9, 10 dan
rentang angka kedua adalah 2, 3, 4, 5, 6. Elemen terakhir dalam larik adalah 3, dan ada 3 angka yang
tumpang tindih di antara kedua rentang: 4, 5, dan 6. Jika kedua rentang tidak tumpang tindih dengan
setidaknya x angka, maka program Anda harus mengembalikan string false .
Contoh
Masukan: [5,11,1,5,1]
Keluaran: benar
Masukan: [1,8,2,4,4]
Keluaran: salah
function OverlappingRanges(arr) {
var target = arr.pop();
var MaxLowerBound = Math.max(arr[0], arr[2]);
var MinUpperBound = Math.min(arr[1], arr[3]);
rentang var = MinUpperBound - MaxLowerBound + 1;
rentang kembali >= target ? 'benar salah';

}

OverlappingRanges(readline());
biarkan hitung = 0;
for (biarkan i = arr[0]; i <= arr[1]; i++) {
jika (i >= arr[2] && i <= arr[3]) {
hitung++;
}
}
return (hitung >= arr[4]) ? benar salah;
}

var range1 = [arr[0], arr[1]]; // (a,b)
var range2 = [arr[2], arr[3]]; // (c, d)
var minimumTumpang tindih = arr[4] - 1;
// menentukan tumpang tindih antara dua rentang

// angka negatif berarti tidak ada tumpang tindih
fungsi tumpang tindih(rentang1, rentang2) {
if (rentang1[0] <rentang2[0]) {
// a----b
// c----d
kembali (rentang1[1] > rentang2[1] ? rentang2[1] : rentang1[1]) -
rentang2[0];
} kalau tidak {
// a----b
// c---d
kembali (rentang2[1] > rentang1[1] ? rentang1[1] : rentang2[1]) -
rentang1[0];
}
}
return overlap(range1, range2) >= minimumTumpang tindih;

}

Superincreating
Miliki fungsi Superincreasing( arr ) ambil larik angka yang disimpan di arr dan tentukan
apakah larik tersebut membentuk urutan supernaik di mana setiap elemen dalam larik lebih besar dari
jumlah semua elemen sebelumnya. Array hanya akan terdiri dari bilangan bulat positif. Sebagai contoh:
jika arr adalah [1, 3, 6, 13, 54] maka program Anda harus mengembalikan string "true" karena
membentuk urutan superincreasing. Jika urutan superincreasing tidak terbentuk, maka program Anda
harus mengembalikan string "false"
Contoh
Masukan: [1,2,3,4]
Keluaran: salah
Masukan: [1,2,5,10]
Keluaran: benar
function Superincreasing(arr) {
var maxInd = arr.panjang - 1;
target var;
var jumlah;
for (var i = maxInd; i > 0; i--) {

target = arr.pop()
jumlah = arr.kurangi(fungsi(val1, val2) {
kembalikan val1 + val2;
});
if (jumlah >= target) {
kembali 'salah';
}
};
kembali 'benar';
}
Superincreasing(readline());
for (misalkan i = 0, sum = 0; i < arr.length; i++) {

jika (arr[i] <= jumlah) {
kembali salah;
}
jumlah += arr[i];
}
kembali benar;
}

if (arr.length < 2) return false;
if (arr.panjang === 2) return arr[0] < arr[1];
if (arr[0] >= arr[1]) return false;
var total = arr[0] + arr[1];

if (arr[i] <= total) return false;
total += arr[i];
}
kembali benar;
}

Jarak Hamming
Apakah fungsi HammingDistance( strArr ) mengambil larik string yang disimpan di strArr ,
yang hanya akan berisi dua string dengan panjang yang sama dan mengembalikan jarak Hamming di
antara keduanya. Jarak Hamming adalah jumlah posisi di mana karakter yang sesuai berbeda. Misalnya:
jika strArr adalah ["coder", "codec"] maka program Anda harus mengembalikan 1 . String akan selalu
memiliki panjang yang sama dan hanya berisi karakter huruf kecil dari alfabet dan angka.
Contoh
Masukan: ["10011", "10100"]

Keluaran: 3
Masukan: ["helloworld", "worldhello"]
Keluaran: 8
function HammingDistance(strArr) {
biarkan hitung = 0;
for (biarkan i = 0; i < strArr[0].length; i++) {
if (strArr[0][i] !== strArr[1][i]) {
menghitung++
}
}
}

HammingDistance(readline());
var kata1 = strArr[0],
kata2 = strArr[1],
len = kata1.panjang,
hitungan = 0;

if (kata1[i] !== kata2[i]) {
hitung++;
}
}
}

var hammingJarak = 0;
for (var i = 0; i < strArr[0].length; i++) {
if (strArr[0][i] !== strArr[1][i]) {
hammingDistance++;
}
}
return hammingDistance;
}

Luas Persegi Panjang

Solusi Pengguna Teratas
function RectangleArea(strArr) {
var obj = {};
obj.x1 = parseInt(strArr[0].match(/((-*d+)/)[1], 10);
obj.y1 = parseInt(strArr[0].cocok(/(-*d+))/)[1], 10);
untuk (var i = 1; i < 3; i++) {

if (obj.x1 !== parseInt(strArr[i].match(/((-*d+)/)[1], 10)) {
obj.x2 = parseInt(strArr[i].match(/((-*d+)/)[1], 10);
}
if (obj.y1 !== parseInt(strArr[i].match(/(-*d+))/)[1], 10)) {
obj.y2 = parseInt(strArr[i].match(/(-*d+))/)[1], 10);
}
}
if (Object.keys(obj).length !== 4) {
kembali 0;
} kalau tidak {
kembali (Math.abs(obj.x1 - obj.x2) * Math.abs(obj.y1 - obj.y2));
}
}

Luas Persegi Panjang(garis baca());
// Mengurai input ke dalam array

biarkan coords = strArr.map(function(val){
biarkan coords = val.split(' ');
biarkan x = parseInt(koords[0].substr(1, koords[0].panjang-1));
biarkan y = parseInt(koords[1].substr(0, koords[1].panjang-1));
kembali [x, y];
});
biarkan titik = coords.shift();

misalkan x = titik[0];
misalkan y = titik[1];
biarkan deltaX = 0;
biarkan deltaY = 0;
coords.forEach(function(val){
jika (x === val[0]) {
deltaY = Math.abs(val[1] - y);
}
jika (y === val[1]) {
deltaX = Math.abs(val[0] - x);
}
});
kembalikan deltaX * deltaY;

var poin = strArr.map(str => str.match(/\d+/g));
var minX = poin.peta(titik => titik[0]).sort()[0];
var minY = poin.peta(titik => titik[1]).sort()[0];
var maxX = poin.peta(titik => titik[0]).sort().reverse()[0];
var maxY = poin.peta(titik => titik[1]).sort().reverse()[0];
kembali (maxX - minX) * (maxY - minY);

}

Bitwise One
Memiliki fungsi BitwiseOne( strArr ) mengambil larik string yang disimpan di strArr , yang
hanya akan berisi dua string dengan panjang yang sama yang mewakili bilangan biner, dan
mengembalikan string biner terakhir yang melakukan operasi bitwise OR pada kedua string. Operasi
bitwise OR menempatkan 0 di string baru di mana ada nol di kedua string biner, jika tidak maka
menempatkan 1 di tempat itu. Sebagai contoh: jika strArr adalah ["1001", "0100"] maka program
Anda harus mengembalikan string "1101"
Contoh
Masukan: ["100", "000"]

Pengeluaran: 100
Masukan: ["00011", "01010"]

Keluaran: 01011
LIHAT TANTANGAN
function BitwiseOne(strArr) {
var str1 = strArr[0];
var str2 = strArr[1];
var newStr = '';
len = str1.panjang;

if(str1.charAt(i) === '1' || str2.charAt(i) === '1') {
newStr = newStr += '1';
} kalau tidak {
newStr = newStr += '0';
}
}

}
BitwiseOne(readline());
var keluaran = '';
if (strArr[0][i] === '1' || strArr[1][i] === '1') {
keluaran += '1';
} kalau tidak {
keluaran += '0';
}
}
kembali keluaran;
}


stringbaru += parseInt(strArr[0][i]) || parseInt(strArr[1][i]);
}
}

Produk-produk lain
Miliki fungsi OtherProducts( arr ) ambil larik angka yang disimpan di arr dan kembalikan
daftar produk baru dari semua angka lain dalam larik untuk setiap elemen. Misalnya: jika arr adalah [1,
2, 3, 4, 5] maka larik baru, di mana setiap lokasi dalam larik baru adalah produk dari semua elemen
lainnya , adalah [120, 60, 40, 30, 24]. Perhitungan berikut dilakukan untuk mendapatkan jawaban ini:
[(2*3*4*5), (1*3*4*5), (1*2*4*5), (1*2*3*5) , (1*2*3*4)]. Anda harus membuat larik baru ini dan
kemudian mengembalikan angka sebagai string yang digabungkan dengan tanda hubung: 120-60-40-30-
24 . Array akan berisi paling banyak 10 elemen dan setidaknya 1 elemen bilangan bulat positif saja.
Contoh
Masukan: [1,4,3]
Keluaran: 12-3-4
Masukan: [3,1,2,6]
Keluaran: 12-36-18-6
function OtherProducts(arr) {
biarkan holdArray = [];
arr.forEach((val, ind, theArray) => {

newArray = Array.dari(Array)
newArray.splice(ind,1)
holdArray[ind] = newArray.reduce((val1, val2) => val1 * val2);

})
kembali holdArray.join('-');
}

Produk Lainnya(readline());
biarkan hasil = [];

biarkan hasil kali = 1;
for (biarkan j = 0; j < arr.panjang; j++) {
jika (i !== j) {
produk *= arr[j];
}
}
hasil.push(produk);
}
kembalikan hasil.bergabung('-');
}

fungsi produk(arr) {
return arr.reduce((a,b) => a * b);
}
var produk = [];
var lainnya = arr.slice(0, i).concat(arr.slice(i + 1));
produk.push(produk(lainnya));
}
kembalikan produk.bergabung('-');
}

Penyortiran Gelombang
Miliki fungsi WaveSorting( arr ) ambil larik bilangan bulat positif yang disimpan dalam arr dan
kembalikan string dengan benar jika angka dapat diatur dalam pola gelombang: a1 > a2 < a3 > a4 < a5
> ... , jika tidak, kembalikan string salah . Misalnya, jika arr adalah: [0, 1, 2, 4, 1, 4], maka urutan
gelombang yang mungkin dari bilangan tersebut adalah: [2, 0, 4, 1, 4, 1]. Jadi untuk input ini, program
Anda harus mengembalikan string true . Array input akan selalu berisi setidaknya 2 elemen. Lebih
banyak contoh diberikan di bawah ini sebagai contoh kasus uji.
Contoh
Masukan: [0, 1, 2, 4, 1, 1, 1]
Keluaran: salah
Masukan: [0, 4, 22, 4, 14, 4, 2]

Keluaran: benar
fungsi Penyortiran Gelombang(arr) {
// memikirkannya, hasil yang diinginkan akan mungkin terjadi selama kita tidak
memiliki satu nomor pun
// lebih banyak dari angka lain untuk memecahnya
// dapatkan jumlah total angka

biarkan panjang = arr.panjang;
// dapatkan jumlah entri untuk setiap nomor

biarkan countObj = {};
arr.forEach(val => {
if (!countObj[val]) {
countObj[val] = 1;
} kalau tidak {
countObj[val]++;
}
});
// buat array dari hasil kita, sehingga kita dapat menemukan maks
biarkan countArr = [];
for (biarkan memasukkan countObj) {
countArr.push(countObj[key]);
}
//temukan maks - tidak perlu menggunakan apply() lagi!

biarkan maxCount = Math.max(...countArr);
kembalikan maxCount > panjang/2 ? salah benar;

Penyortiran Gelombang(readline());
arr = arr.sort((a,b) => a - b).reverse();

newArr = [];
biarkan setengahPanjang = Math.floor(arr.length / 2);
newArr = [];
for (biarkan i = 0, n = arr.panjang; i < n; i++) {

jika (i % 2 === 0) {
newArr.push(arr.splice(0, 1));
} kalau tidak {
// Lihat dan ambil elemen selanjutnya yang lebih kecil dari arr[i]
for (biarkan j = 1; j < arr.panjang; j++) {
jika (arr[j] < arr[0]) {
newArr.push(arr.splice(j, 1));
merusak;
}
}
}
// Periksa apakah Arr baru adalah gelombang yang diurutkan

for (biarkan i = 0; i < newArr.length-1; i++) {
jika (i % 2 === 0) {
// i > i+1 = benar
if (parseInt(newArr[i]) <= parseInt(newArr[i+1])) {
kembali salah;
}
} kalau tidak {
// i < i+1 = benar
if (parseInt(newArr[i]) >= parseInt(newArr[i+1])) {
kembali salah;
}
}
}
kembali benar;
}

// temukan jumlah elemen yang paling sering muncul, yaitu mode

fungsi paling sering(arr) {
arr.sort();
var terbanyak = 0;
var frekuensi = 1;
jika (arr[i] === arr[i + 1]) {
frekuensi++;
if (frekuensi > kebanyakan) {
kebanyakan = frekuensi;
}
} kalau tidak {
frekuensi = 1;
}
}
kembali paling banyak;
}

// selama kita bisa memasukkan nomor lain di antara nomor yang sama, itu
berfungsi
return mostFrequent(arr) < (arr.length / 2);
}

Pencocokan Array
Memiliki fungsi ArrayMatching( strArr ) membaca larik string yang disimpan di strArr yang
hanya akan berisi dua elemen, keduanya akan mewakili larik bilangan bulat positif. Misalnya: jika
strArr adalah ["[1, 2, 5, 6]", "[5, 2, 8, 11]"], maka kedua elemen dalam input mewakili dua larik
bilangan bulat, dan sasaran Anda untuk tantangan ini adalah untuk menambahkan elemen di lokasi yang
sesuai dari kedua larik. Untuk input contoh, program Anda harus melakukan penambahan berikut: [(1 +
5), (2 + 2), (5 + 8), (6 + 11)] yang kemudian sama dengan [6, 4, 13, 17] . Program Anda akhirnya harus
mengembalikan array yang dihasilkan ini dalam format string dengan setiap elemen dipisahkan oleh
tanda hubung: 6-4-13-17 .
Jika kedua larik tidak memiliki jumlah elemen yang sama, cukup tambahkan elemen yang tersisa ke larik
baru (contoh ditunjukkan di bawah). Kedua larik akan memiliki format: [e1, e2, e3, ...] di mana
setidaknya satu elemen akan ada di setiap larik.
Contoh
Masukan: ["[5, 2, 3]", "[2, 2, 3, 10, 6]"]

Keluaran: 7-4-6-10-6
Masukan: ["[1, 2, 1]", "[2, 1, 5, 2]"]

Keluaran: 3-3-6-2
function ArrayMatching(strArr) {
strArr = strArr.peta(val => val.ganti(/[[]]/g, '')
.split(/s*,s*/).map(val1 => parseInt(val1, 10)));
biarkan reArr = [];

biarkan arr1 = strArr[0];
biarkan arr2 = strArr[1];
biarkan panjang = Math.max(arr1.length, arr2.length);
for (biarkan i = 0; i < panjang; i++) {

if (arr1[i] && arr2[i]) {
resArr[i] = arr1[i] + arr2[i];
} kalau tidak {
resArr[i] = arr1[i] || arr2[i];
}
}
return resArr.join('-');

ArrayMatching(readline());
biarkan angka1 = strArr[0].substr(1, strArr[0].panjang-1).split(', ');

biarkan angka2 = strArr[1].substr(1, strArr[1].length-1).split(', ');
biarkan maxLength = (angka1.panjang > angka2.panjang) ? angka1.panjang :

angka2.panjang;
biarkan hasil = [];
for (biarkan i = 0; i < maxLength; i++) {

biarkan num1 = (i < angka1.panjang) ? parseInt(angka1[i]) : 0;
biarkan num2 = (i < angka2.panjang) ? parseInt(angka2[i]) : 0;
hasil.push(num1 + num2);
}
kembalikan hasil.bergabung('-');
}

arr1 = strArr[0].match(/\d+/g).map(Angka);
arr2 = strArr[1].match(/\d+/g).map(Angka);
if (arr1.panjang > arr2.panjang) {

arr2 = arr2.concat(Array baru(arr1.panjang - arr2.panjang).isi(0));
} lain jika (arr1.panjang < arr2.panjang) {
arr1 = arr1.concat(Array baru(arr2.panjang - arr1.panjang).isi(0));
}
var jumlah = [];
for (var i = 0; i < arr1.length; i++) {
sum.push(arr1[i] + arr2[i]);
}
kembali jumlah.bergabung('-');
}

Pembalikan Biner
Memiliki fungsi BinaryReversal( str ) ambil parameter str yang diteruskan, yang akan menjadi
bilangan bulat positif, ambil representasi binernya (diisi ke N * 8 bit terdekat), balikkan string bit itu,
dan akhirnya kembalikan string terbalik baru dalam bentuk desimal. Sebagai contoh: jika str adalah
"47" maka versi biner dari bilangan bulat ini adalah 101111 tetapi kita padukan menjadi 00101111 .
Program Anda harus membalikkan string biner ini yang kemudian menjadi: 11110100 dan akhirnya
mengembalikan versi desimal dari string ini, yaitu 244 .
Contoh
Masukan: "213"
Keluaran: 171
Masukan: "4567"
Keluaran: 60296
function BinaryReversal(str) {
biarkan num = parseInt(str, 10)

.toString(2);
biarkan panjang = num.panjang;
//tambahkan angka nol di depan untuk menjadikan bilangan tersebut sebagai

bilangan integral byte
biarkan byteString = `${'0'.repeat(panjang % 8 === 0 ? 0 : 8 - panjang % 8)}$
{num}`;
biarkan stringByte = byteString.split('')

.balik()
.bergabung('');
return parseInt(stringByte, 2).toString();

BinaryReversal(readline());
biarkan biner = parseInt(str).toString(2);
biarkan ukuran = Math.ceil(binary.length/8) * 8;

while (binary.length < ukuran) {
biner = '0' + biner;
}

for (biarkan i = 0; i < binary.length; i++) {
stringbaru = biner[i] + stringbaru;
}
return parseInt(newString, 2);

}

fungsi toBinary(str) {
hasil = Angka(str).toString(2);
// pad kiri dengan awalan 0 untuk menjadikannya kelipatan 8 digit...
jika (hasil.panjang % 8 !== 0)
return new Array(8 - (result.length % 8)).fill(0).join('') + result;
lain mengembalikan hasil;
}
fungsi toDecimal(str) {
return parseInt(str, 2);
}
//kembali keBinary(str);
var mundur = toBinary(str).split('').reverse().join('');
kembali keDesimal(terbalik);
}

Urutan Peningkatan Terpanjang
Miliki fungsi LongestIncreasingSequence( arr ) mengambil larik bilangan bulat positif yang
disimpan di arr dan mengembalikan panjang urutan peningkatan terpanjang (LIS). LIS adalah
subhimpunan dari daftar asli di mana angka-angkanya diurutkan, dari terendah ke tertinggi, dan dalam
urutan meningkat. Urutannya tidak perlu berurutan atau unik, dan bisa terdapat beberapa urutan yang
berbeda. Misalnya: jika arr adalah [4, 3, 5, 1, 6] maka kemungkinan LIS adalah [3, 5, 6], dan yang
lainnya adalah [1, 6]. Untuk input ini, program Anda harus mengembalikan 3 karena itu adalah panjang
dari urutan peningkatan terpanjang.
Contoh
Masukan: [9, 9, 4, 2]
Keluaran: 1
Masukan: [10, 22, 9, 33, 21, 50, 41, 60, 22, 68, 90]
Keluaran: 7
function LongestIncreasingSequence(arr) {
biarkan len = arr.panjang;
biarkan arrHolder = [];
// evaluasi setiap kemungkinan kombinasi angka

untuk (biarkan saya = Math.pow(2, len); i < Math.pow(2, len + 1); i++) {
//numArray adalah digit biner, 0 dan 1 mewakili apakah akan disertakan

// nomor atau tidak dalam array kombinasi. Akan ada 2 ^ n kombinasi
//untuk mendapatkan nol di depan, gunakan angka dari 2^n hingga 2^n+1, lalu
potong 1 di depan
biarkan numArray = i.toString(2).slice(1).split('');
// tahan nomor yang dipilih di array newSeq

newSeq = [];
//mengisi array newSeq

arr.forEach((val, ind) => {
if (numArray[ind] === '1') {
newSeq.push(val);
}
});
// sertakan array newSeq ke dalam arrHolder

arrHolder.push(newSeq);
}
//keluarkan semua array yang tidak menaik (gunakan ascend() untuk menentukan)
arrHolder = arrHolder.filter(val => naik(val));
//ganti setiap array yang lewat dengan panjangnya

biarkan arrLength = arrHolder.map(val => val.length);
// mengembalikan nilai panjang terbesar

return Math.max(...arrLength);
}
fungsi naik(inputArr) {
biarkan arrlen = inputArr.panjang;
kembalikan inputArr.every((val, ind) => {
if (ind < arrlen - 1) {
return val < inputArr[ind + 1];
}
kembali benar;
});
}

Urutan Peningkatan Terpanjang(readline());
// https://stackoverflow.com/questions/2631726/how-to-determine-the-longest-
increasing-subsequence-using-dynamic-programming
// Digunakan algoritma dari sini
biarkan lis = [arr[0]];

if (arr[i] > lis[lis.panjang - 1]) {
lis.push(arr[i]);
melanjutkan;
}
for (biarkan j = 0; j < lis.panjang; j++) {

if (lis[j] >= arr[i]) {
lis[j] = arr[i];
merusak;
}
}
}
return lis.panjang;

// menghasilkan n permutasi benar/salah

// ini akan digunakan untuk menghasilkan urutan - untuk memasukkan elemen ini atau
tidak
permutasi fungsi(n) {
jika (n < 1) mengembalikan nol;
if (n < 2) return [[benar], [salah]];
var sebelumnya = permutasi(n - 1);
var hasil = [];
for (var permutasi sebelumnya) {
result.push(permutation.concat([true]));
result.push(permutation.concat([false]));
}
}
// dapatkan semua kemungkinan urutan berikutnya

fungsi getSubSequences(arr) {
return permute(arr.length).map(function(permutation) {
var hasil = [];
for (var i = 0; i < permutation.length; i++) {
if (permutasi[i]) {
result.push(arr[i]);
}
}
});
}
fungsi meningkat(arr) {
return arr.setiap(fungsi(nilai, indeks, arr) {
var prev = (indeks === 0) ? 0: arr[indeks - 1];
kembali prev < nilai;
});
}
var terpanjang = 0;
var subSequences = getSubSequences(arr);

untuk (var subSequence dari subSequences) {
if(meningkat(subSequence) && subSequence.length > terpanjang) {
terpanjang = subSequence.panjang;
}
}
kembali terpanjang;
}

Pasangan Genap
Miliki fungsi EvenPairs( str ) ambil parameter str yang diteruskan dan tentukan apakah sepasang
bilangan genap yang berdekatan ada di mana saja dalam string. Jika ada pasangan, kembalikan string
true , jika tidak kembalikan false . Sebagai contoh: jika str adalah "f178svg3k19k46" maka ada dua
angka genap di akhir string, "46" sehingga program Anda harus mengembalikan string true . Contoh
lain: jika str adalah "7r5gg812" maka pasangannya adalah "812" (8 dan 12) sehingga program Anda
harus mengembalikan string true .
Contoh
Masukan: "3gy41d216"
Keluaran: benar
Masukan: "f09r27i8e67"
Keluaran: salah
function EvenPairs(str) {
var regex = /[24680]d*[24680]/
return regEx.test(str);

EvenPairs(readline());
const DIGITS = '0123456789';
biarkan numberGroups = [];
// Dapatkan grup digit

for (biarkan i = 0, digitStr = ''; i < str.length; i++) {
biarkan isDigit = DIGITS.includes(str[i]);
jika (isDigit) {
digitStr += str[i];
}
if (digitStr.panjang > 0 && (i === str.panjang - 1 || !isDigit)) {

numberGroups.push(digitStr);
digitStr = '';
}
}
// Hanya peduli dengan panjang grup > 1

numberGroups = numberGroups.filter(v => v.panjang > 1);
// Ulangi semua "grup"

for (biarkan i = 0; i < numberGroups.length; i++) {
// Loop bersarang untuk setiap grup
for (biarkan j = 0; j < numberGroups[i].length; j++) {
for (misalkan k = j + 1; k < numberGroups[i].length; k++) {
biarkan str1 = numberGroups[i].substr(0, j+1);
biarkan str2 = numberGroups[i].substr(j+1, k);
if (parseInt(str1) % 2 === 0 && parseInt(str2) % 2 === 0) {
kembali benar;
}
}
}
}
kembali salah;
}

// lihat apakah ada lebih dari dua pasang bilangan genap

fungsi hasEvenPairs(angka) {
// pencocokan angka genap yang tidak serakah
var result = number.toString().match(/\d*?[24680]/g);
kembali (hasil === null) ? false : (hasil.panjang >= 2);
}
var angka = str.cocok(/\d+/g);
untuk (var jumlah angka) {
if (hasEvenPairs(number)) return true;
}
kembali salah;
}

Palindrom berikutnya
Minta fungsi NextPalindrome( num ) ambil parameter num yang diteruskan dan kembalikan
bilangan palindromik terbesar berikutnya. Input dapat berupa bilangan bulat positif apa pun. Sebagai
contoh: jika num adalah 24, maka program Anda harus mengembalikan 33 karena itu adalah angka
terbesar berikutnya yang merupakan palindrom.
Contoh
Masukan: 2
Keluaran: 3
Masukan: 180
Keluaran: 181
fungsi NextPalindrome(num) {
misalkan hitung = bil + 1;
sementara (benar) {
numString = count.toString();
revString = numString.split('')
.balik()
.bergabung('');
if (revString === numString) kembalikan parseInt(numString, 10);
hitung++;
}
}

NextPalindrome(readline());
biarkan Palindrom berikutnya = null;

for (biarkan i = num + 1; ; i++) {
biarkan string = i.toString();
if (isPalindrome(string)) {
palindrom berikutnya = i;
merusak;
}
}
kembali Palindrom berikutnya;
function isPalindrome(str) {
kembali salah;
}
}
kembali benar;
}
}

fungsi isPalindrom(bil) {
var numStr = num.toString();
return numStr.split('').reverse().join('') === numStr;
}
var nextNum = bil + 1;
while (!isPalindrome(nextNum)) {
nextNum++;
}
kembalikan nextNum;
}

Pasangan Terbesar
Mintalah fungsi LargestPair( num ) ambil parameter num yang diteruskan dan tentukan angka dua
digit terbesar di dalam bilangan bulat. Sebagai contoh: jika num adalah 4759472 maka program Anda
harus mengembalikan 94 karena itu adalah angka dua digit terbesar. Input akan selalu berisi setidaknya
dua digit positif.
Contoh
Masukan: 453857
Keluaran: 85
Masukan: 363223311
Keluaran: 63
function LargestPair(num) {
biarkan numStr = num.toString();
biarkan numArr = numStr.split('')

.map(val => parseInt(val, 10));
//singkirkan digit terakhir, seandainya itu yang terbesar;

numArr.pop();
biarkan maxNum = Math.max(...numArr);
biarkan regEx = new RegExp(`${maxNum}\d`, 'g');
biarkan cocok = numStr.match(regEx);
kembalikan pertandingan.sort((a, b) => a - b).pop();

}

Pasangan Terbesar(garis baca());
biarkan Bilangan terbesar = 0;

biarkan testNum = parseInt(num[i-1] + num[i]);
if (testNum > greatestNum) {
TerbesarNum = TestNum;
}
}
kembalikan jumlah terbesar;
}
var maks = 0;
var numStr = num.toString();
// jendela geser dengan ukuran 2

untuk (var i = 0; i < numStr.panjang - 1; i++) {
var testNum = Number(numStr.slice(i, i + 2));
if (testNum > maks) {
maks = jumlah tes;
}
}
pengembalian maks;
}

Karakter yang tidak berulang
Miliki fungsi NonrepeatingCharacter( str ) ambil parameter str yang akan diteruskan, yang
hanya akan berisi karakter alfabet dan spasi, dan kembalikan karakter pertama yang tidak berulang.
Misalnya: jika str adalah "agettkgaeee" maka program Anda harus mengembalikan k . String akan
selalu berisi setidaknya satu karakter dan akan selalu ada setidaknya satu karakter yang tidak berulang.
Contoh
Masukan: "abcdef"
Keluaran:
Masukan: "halo dunia hai hai"

Keluaran: w
function NonrepeatingCharacter(str) {
biarkan len = str.panjang;
biarkan countObj = {}
for (biarkan i = 0; i < len; i++) {

if (countObj[str[i]]) {
countObj[str[i]]++;
}
kalau tidak {
countObj[str[i]] = 1;
}
}
for (biarkan j = 0; j < len; j++) {
if (countObj[str[j]] === 1) return str[j];
}
}

NonrepeatingCharacter(readline());
biarkan pengulanganChars = '';

biarkan hasil = '';
biarkan berulang = salah;
for (biarkan j = i+1; j < str.panjang; j++) {
if (str[i] === str[j] || repeatingChars.includes(str[i])) {
mengulang = benar;
repeatingChars += str[i];
merusak;
}
}
jika (! berulang) {
hasil = str[i];
merusak;
}
}
}

str = str.ganti(/\s+/g, '');
jumlah var = {};
// menghitung setiap huruf

for (var i = 0; i < str.panjang; i++) {
if (str[i] dalam hitungan) {
hitungan[str[i]]++;
} kalau tidak {
hitungan[str[i]] = 1;
}
}
// kembalikan huruf pertama dengan hitungan 1

for (i = 0; i < str.panjang; i++) {
if (counts[str[i]] === 1) return str[i];
}
}

Dua Jumlah
Mintalah fungsi TwoSum( arr ) mengambil larik bilangan bulat yang disimpan dalam arr , dan
tentukan apakah ada dua angka (tidak termasuk elemen pertama) dalam larik yang dapat menjumlahkan
elemen pertama dalam larik. Misalnya: jika arr adalah [7, 3, 5, 2, -4, 8, 11], maka sebenarnya ada dua
pasangan yang berjumlah 7: [5, 2] dan [-4, 11]. Program Anda harus mengembalikan semua pasangan,
dengan angka yang dipisahkan oleh koma, dalam urutan angka pertama yang muncul dalam larik.
Pasangan harus dipisahkan oleh spasi. Jadi untuk contoh di atas, program Anda akan mengembalikan:
5,2 -4,11
Jika tidak ada dua angka yang menjumlahkan elemen pertama dalam array, kembalikan -1
Contoh
Masukan: [17, 4, 5, 6, 10, 11, 4, -3, -5, 3, 15, 2, 7]

Keluaran: 6,11 10,7 15,2
Masukan: [7, 6, 4, 1, 7, -2, 3, 12]

Keluaran: 6,1 4,3
function TwoSum(arr) {
biarkan target = arr.shift();
biarkan holdArr = [];

for (biarkan j = i + 1; j < len; j++) {
if (arr[i] + arr[j] === target) {
holdArr.push(`${arr[i].toString()},${arr[j].toString()}`);
merusak;
}
}
}
kembalikan holdArr.length ? holdArr.bergabung(' '): -1;
}

TwoSum(readline());
const jawaban = arr.shift(arr);

sejarah const = set baru();
pertandingan const = [];
// Tanpa reverse() di sini, hasil akhirnya akan berurutan

// angka kedua muncul di array, tapi kita menginginkannya
// diurutkan berdasarkan angka pertama.
arr.mundur();
arr.forEach(item => {
const pujian = jawaban - item;
if (history.has(pujian)) {
pertandingan.push([item, pujian]);
} kalau tidak {
history.add(item);
}
});
// Pertandingan didorong ke array dalam urutan terbalik, jadi

// sekarang kita perlu menukarnya kembali.
pertandingan.membalikkan();
return (matches.length === 0) ? -1 : pertandingan.peta(m => m.join(',')).join('

');
}

TwoSum(readline());
// temukan pasangan yang merangkum angka yang diberikan

fungsi findPairs(arr, sum) {
pasangan var = [];
for (var j = i + 1; j < arr.panjang; j++) {
jika (arr[i] + arr[j] === jumlah)
pasang.push([arr[i], arr[j]]);
}
}
pasang kembali;
}
pasangan var = [];
var jumlah = arr[0];
var sisanya = arr.slice(1);
pasangan = findPairs(sisa, jumlah);
return (pasangan.panjang === 0) ? -1 : pairs.map(pair => pair.join(',')).join('

');
}

TwoSum(readline());
Bitwise Dua
Memiliki fungsi BitwiseTwo( strArr ) mengambil larik string yang disimpan di strArr , yang
hanya akan berisi dua string dengan panjang yang sama yang mewakili bilangan biner, dan
mengembalikan string biner terakhir yang melakukan operasi bitwise AND pada kedua string. Operasi
bitwise AND menempatkan 1 di string baru di mana ada 1 di kedua lokasi di string biner, jika tidak
maka menempatkan 0 di tempat itu. Sebagai contoh: jika strArr adalah ["10111", "01101"] maka
program Anda harus mengembalikan string "00101"
Contoh
Masukan: ["100", "000"]

Keluaran: 000
Masukan: ["10100", "11100"]

Keluaran: 10100
fungsi BitwiseTwo(strArr) {
biarkan angka1 = strArr[0];
biarkan angka2 = strArr[1];
biarkan len = strArr[0].panjang;
biarkan resStr = '';

if (bilangan1[i] === '1' && bilangan2[i] === '1') {
resStr += '1';
melanjutkan;
}
kalau tidak {
resStr += '0';
melanjutkan;
}
}
kembali resStr;
}

BitwiseTwo(readline());
biarkan newStr = '';

newStr += (strArr[0][i] === strArr[1][i] && strArr[0][i] !== '0') ? '1' :
'0';
}
}

var hasil = '';
if (strArr[0][i] === '1' && strArr[1][i] === '1') {
hasil += '1';
} kalau tidak {
hasil += '0';
}
}
}

Hitungan Set Daya
Miliki fungsi PowerSetCount( arr ) ambil array bilangan bulat yang disimpan di arr , dan
kembalikan panjang set daya (jumlah semua kemungkinan set) yang dapat dihasilkan. Sebagai contoh:
jika arr adalah [1, 2, 3], maka himpunan berikut membentuk himpunan daya:
[]
[1]
[2]
[3]
[1, 2]
[1, 3]
[2, 3]
[1, 2, 3]
Anda dapat melihat di atas semua set yang mungkin, bersama dengan set kosong, dihasilkan. Oleh
karena itu, untuk masukan ini, program Anda harus mengembalikan 8 .
Contoh
Masukan: [1, 2, 3, 4]
Keluaran: 16
Masukan: [5, 6]
Keluaran: 4
fungsi PowerSetCount(arr) {
return Math.pow(2, len);
}
PowerSetCount(readline());
return Math.pow(2, arr.panjang);
}

return Math.pow(2, arr.panjang);
}

Digit Produk
Miliki fungsi ProductDigits( num ) ambil parameter num yang diteruskan yang akan menjadi
bilangan bulat positif, dan tentukan jumlah digit paling sedikit yang perlu Anda kalikan untuk
menghasilkannya. Contoh: jika num adalah 24 maka anda dapat mengalikan 8 dengan 3 yang
menghasilkan 24, maka program anda harus mengembalikan 2 karena total yang diperlukan hanya 2
digit. Contoh lain: jika num adalah 90, Anda dapat mengalikan 10 * 9, jadi dalam hal ini program Anda
harus menghasilkan 3 karena Anda tidak dapat mencapai 90 tanpa menggunakan total 3 digit dalam
perkalian Anda.
Contoh
Masukan: 6
Keluaran: 2
Masukan: 23
Keluaran: 3
function ProductDigits(num) {
biarkan pivot = Math.sqrt(num);
biarkan nilai = num.toString().panjang + 1;
for (biarkan i = 1; i <= pivot; i++) {
jika (bil % i === 0) {
biarkan maxFactor = i;
maxCompFactor = num / maxFactor;
maxFactorString = maxFactor.toString();
maxCompFactorString = maxCompFactor.toString();
biarkan totalLength = maxFactorString.length +
maxCompFactorString.length;
if (totalLength < nilai) {
nilai = totalPanjang;
}
}
}
mengembalikan nilai;
}

ProductDigits(readline());
biarkan pf = primeFactors(num);
jika (pf.panjang === 1) {

return pf[0].toString().length + 1;
}
biarkan faktor = [];
for (biarkan pembagi = 0; pembagi < pf.panjang; pembagi ++) {

biarkan kiri = pf.slice(0, pembagi);
biarkan kanan = pf.slice(pembagi, pf.panjang);
biarkan leftProduct = left.reduce((produk, nilai) => produk *= nilai, 1);

biarkan kananProduk = kanan.mengurangi((produk, nilai) => produk *= nilai,
1);
factors.push([Produk kiri,Produk kanan]);
}
return factors.map(factor => factor.join('').split('').length).reduce((max, val)

=> val < max ? val : max, Number.MAX_SAFE_INTEGER);
function primeFactors(num) {
jika (bil === 1) kembalikan 1;
biarkan pf = [];
for (biarkan i = 2; i <= num; i++) {

jika (bil % i === 0) {
pf.push(i);
bilangan /= i;
saya = 1;
}
}
kembali pf;
}
}

fungsi getDivisors(num) {
var pembagi = [1];
untuk (var i = 2; i <= num / 2; i++) {
jika (bil % i === 0) {
pembagi.push(i);
}
}
pembagi.push(bil);
pembagi kembali;
}
var pembagi = getDivisors(num);
pasangan var = [];
for (var i = 0; i < pembagi.panjang / 2; i++) {

pairs.push([pembagi[i], pembagi[(pembagi.panjang - 1) - i]]);
}
return pairs.map(pair => ('' + pair[0] + pair[1]).length).sort()[0];

}

Pencipta Palindrom
Mintalah fungsi PalindromeCreator( str ) ambil parameter str yang diteruskan dan tentukan
apakah mungkin untuk membuat string palindromik dengan panjang minimum 3 karakter dengan
menghapus 1 atau 2 karakter. Misalnya: jika str adalah "abjchba" maka Anda dapat menghapus
karakter jc untuk menghasilkan "abhba" yang merupakan palindrom. Untuk contoh ini, program Anda
harus mengembalikan dua karakter yang telah dihapus tanpa pembatas dan dalam urutan kemunculannya
dalam string, jadi jc . Jika 1 atau 2 karakter tidak dapat dihapus untuk menghasilkan palindrom, maka
kembalikan string not possible . Jika string input sudah menjadi palindrom, program Anda harus
mengembalikan string palindrom .
Input hanya akan berisi karakter alfabet huruf kecil. Program Anda harus selalu berusaha untuk membuat
substring palindromik terpanjang dengan menghapus 1 atau 2 karakter (lihat kasus uji sampel kedua
sebagai contoh). 2 karakter yang Anda hapus tidak harus berdekatan dalam string.
Contoh
Masukan: "mmop"
Keluaran: tidak mungkin
Masukan: "kjjjhjjj"
Keluaran: k
function PalindromeCreator(str) {
// tes untuk melihat apakah itu sudah Palindrom
if (isPalindrome(str)) {
kembalikan 'palindrom';
}
biarkan testArray = str.split('');
biarkan res = testArray.splice(i, 1);
biarkan newString = testArray.join('');
if (isPalindrome(newString)) {
console.log('satu');
kembali res.bergabung('');
}
}
biarkan res = [];
for (biarkan j = i; j < len - 1; j++) {
biarkan testArray = str.split('');
res[0] = testArray.splice(i, 1);
res[1] = testArray.splice(j, 1);
biarkan newString = testArray.join('');
if(isPalindrome(newString)) {
kembali res.bergabung('');
}
}
}
kembali 'tidak mungkin';
}
//----------------pembantu---------------------------
biarkan newStr = str.split('').reverse().join('');
if (newStr === str) {
kembali benar;
}
kembali salah;
}

PalindromeCreator(readline());
if (isPalindrome(str)) {
kembalikan 'palindrom';
}
// Buat kombo
biarkan kombo = [];
for (biarkan i = 0, max = Math.pow(2, str.length); i < max; i++) {
biarkan kombo = i.toString(2);
// Filter untuk nol, satu, atau dua 1 (1 mewakili penghapusan)

biarkan hitung = 0;
for (biarkan j = 0; j < combo.length; j++) {
if (kombo[j] === '1') {
hitung++;
}
}
// Terlalu besar, abaikan dan coba lagi!
if (hitung > 2) {
melanjutkan;
}
// Pad kombo yang bagus

while (kombo.panjang < str.panjang) {
kombo = '0' + kombo;
}
kombo.push(kombo);
}
biarkan palindromeCombos = [];
// Coba kombo penghapusan

for (biarkan i = 0; i < combos.length; i++) {
biarkan tryString = '';
for (biarkan j = 0; j < kombo[i].panjang; j++) {
tryString += (kombo[i][j] === '1') ? '' : str[j];
}
if (tryString.length >= 3 && isPalindrome(tryString)) {

palindromeCombos.push(combo[i]);
}
}
if (palindromeCombos.panjang === 0) {
}
// Urutkan jadi dua huruf pertama yang ditemukan akan dikembalikan pertama untuk
kapan
// ada beberapa nilai
palindromeCombos.sort(fungsi(a,b){
kembalikan parseInt(a,2) < parseInt(b,2);
});
// Temukan dan kembalikan penghapusan terpendek <=> palindrom terpanjang

biarkan shortestCount = null;
biarkan kombo terpendek = '';
palindromeCombos.forEach(fungsi(kombo){
biarkan hitung = 0;
for (biarkan i = 0; i < combo.length; i++) {
if (kombo[i] === '1') {
hitung++;
}
}
if (Jumlahterpendek === null || hitung <Jumlahterpendek) {
shortestCount = hitung;
kombo terpendek = kombo;
}
});
biarkan hasil = '';

if (kombo terpendek[i] === '1') {
hasil += str[i];
}
}
kembali (str === str.split('').reverse().join('')) ? benar salah;
}

kembali str === str.split('').reverse().join('');
}
if (isPalindrome(str)) return 'palindrome';

// hapus satu karakter di posisi i
var newStr = str.slice(0, i).concat(str.slice(i + 1));
if (isPalindrome(newStr)) {
kembali str[i];
}
}

// hapus dua karakter di posisi i dan j, di mana (i < j)
for (var j = i + 1; j < str.panjang; j++) {
var newStr2 = str.slice(0, i).concat(str.slice(i + 1,
j)).concat(str.slice(j + 1));
if (isPalindrome(newStr2)) {
return str[i] + str[j];
}
}
}
kembali "tidak mungkin";
}

Angka Romawi Dasar
Miliki fungsi BasicRomanNumerals( str ) read str yang akan menjadi string angka Romawi.
Angka yang digunakan adalah: I untuk 1, V untuk 5, X untuk 10, L untuk 50, C untuk 100, D untuk 500
dan M untuk 1000. Dalam angka Romawi, untuk membuat angka seperti 11 Anda cukup menambahkan 1
setelah 10, sehingga Anda mendapatkan XI . Tetapi untuk membuat angka seperti 19, Anda
menggunakan notasi pengurangan yaitu menambahkan I sebelum X atau V (atau menambahkan X
sebelum L atau C). Jadi 19 dalam angka Romawi adalah XIX .
Tujuan program Anda adalah mengembalikan persamaan desimal dari angka Romawi yang diberikan.
Misalnya: jika str adalah "XXIV", program Anda harus mengembalikan 24
Contoh
Masukan: "IV"
Keluaran: 4
Masukan: "XLVI"
Keluaran: 46
functionBasicRomanNumerals(str) {
biarkan hurufObj = {
saya: 1,
V: 5,
X: 10,
L: 50,
C: 100,
D: 500,
M: 1000
}
misalkan res = 0;
if (!hurufObj[str[i + 1]] || hurufObj[str[i]] >= hurufObj[str[i + 1]]) {
res += hurufObj[str[i]];
} kalau tidak {
res += (hurufObj[str[i + 1]] - hurufObj[str[i]]);
saya++;
}
}
kembalikan res;
}

BasicRomanNumerals(readline());
/*
Simbol SAYA V X L C D M
Nilai1 5 10 50 100 500 1,000
*/
const ROMAN_I = 1;
const ROMAN_V = 5;
const ROMAN_X = 10;
const ROMAN_L = 50;
const ROMAN_C = 100;
const ROMAN_D = 500;
const ROMAN_M = 1000;
biarkan jumlah = 0;

biarkan simbol = str[i];
biarkan nextSymbol = (i+1 >= str.length) ? null : str[i+1];
beralih(simbol) {
kasus 'Saya':
if (nextSymbol === 'V') {
jumlah += ROMAN_V - ROMAN_I;
saya++;
} else if (nextSymbol === 'X') {
jumlah += ROMAN_X - ROMAN_I;
saya++;
} kalau tidak {
jumlah += ROMAN_I;
}
merusak;
kasus 'V':
jumlah += ROMAN_V;
merusak;
kasus 'X':
if (nextSymbol === 'L') {
jumlah += ROMAN_L - ROMAN_X;
saya++;
} else if (nextSymbol === 'C') {
jumlah += ROMAN_C - ROMAN_X;
saya++;
} kalau tidak {
jumlah += ROMAN_X;
}
merusak;
kasus 'L':
jumlah += ROMAN_L;
merusak;
kasus 'C':
if (nextSymbol === 'D') {
jumlah += ROMAN_D - ROMAN_C;
saya++;
} else if (nextSymbol === 'M') {
jumlah += ROMAN_M - ROMAN_C;
saya++;
} kalau tidak {
jumlah += ROMAN_C;
}
merusak;
kasus 'D':
jumlah += ROMAN_D;
merusak;
kasus 'M':
jumlah += ROMAN_M;
merusak;
bawaan:
// Karakter atau ruang ilegal
merusak;
}
}
}

var desimal = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
var romans = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV ',
'SAYA'];
var keluaran = 0;
for (var i = 0; i < romans.length; i++) {

// terus berlari selagi ada kecocokan di awal
while (str.indexOf(romans[i]) === 0) {
keluaran += desimal[i];
str = str.ganti(roma[i], '');
}
}
kembali keluaran;
}

Distribusi Makanan
Memiliki fungsi FoodDistribution( arr ) membaca larik angka yang disimpan dalam arr yang
akan mewakili tingkat kelaparan orang yang berbeda mulai dari 0 hingga 5 (0 berarti tidak lapar sama
sekali, 5 berarti sangat lapar). Anda juga akan memiliki N sandwich untuk dibagikan yang berkisar dari
1 hingga 20. Format array adalah [N, h1, h2, h3, ...] di mana N mewakili jumlah sandwich yang Anda
miliki dan sisa array akan mewakili tingkat kelaparan orang yang berbeda. Tujuan Anda adalah untuk
meminimalkan perbedaan rasa lapar antara setiap pasangan orang dalam susunan menggunakan sandwich
yang Anda miliki.
Misalnya: jika arr adalah [5, 3, 1, 2, 1], ini berarti Anda memiliki 5 sandwich untuk dibagikan. Anda
dapat membagikannya dengan urutan sebagai berikut kepada orang-orang: 2, 0, 1, 0. Memberikan
sandwich ini kepada orang-orang tingkat kelaparan mereka sekarang menjadi: [1, 1, 1, 1]. Selisih antara
setiap pasang orang sekarang adalah 0, totalnya juga 0, jadi program Anda harus mengembalikan 0 .
Catatan: Anda mungkin tidak perlu memberikan semua, atau bahkan sebagian, sandwich Anda untuk
menghasilkan perbedaan yang diminimalkan.
Contoh lain: jika arr adalah [4, 5, 2, 3, 1, 0] maka Anda dapat mendistribusikan sandwich dengan
urutan sebagai berikut: [3, 0, 1, 0, 0] yang menjadikan semua tingkat kelaparan sebagai berikut: [2, 2, 2,
1, 0]. Perbedaan antara setiap pasangan orang sekarang adalah: 0, 0, 1, 1 dan program Anda harus
mengembalikan perbedaan akhir yang diminimalkan dari 2 .
Contoh
Masukan: [5, 2, 3, 4, 5]
Keluaran: 1
Masukan: [3, 2, 1, 0, 4, 1, 0]
Keluaran: 4
function FoodDistribution(arr) {
biarkan memperlakukan = arr.shift();
biarkan myArray = arr.slice(0);
biarkan arrMin = arr.sort((val1, val2) => val2 - val1).pop()
biarkan len = myArray.panjang;
// periksa untuk melihat apakah kita memiliki cukup suguhan untuk membawa
semua orang ke level terbaik saat ini
biarkan testCount = myArray.reduce((val1, val2) => {
kembalikan val1 + val2 - arrMin;
}, 0);
if (testCount <= memperlakukan) {
kembali 0;
}
biarkan valQuantArr = mengobjektifkan(myArray);
for (biarkan i = 1; i < 25; i++) {

biarkan arrayLen = valQuantArr.panjang;
biarkan resp = flattenMid(valQuantArr, suguhan, i);
valQuantArr = resp[0];
arrayLen = valQuantArr.panjang;
suguhan = resp[1];
while (valQuantArr[0].quant <= i && valQuantArr[0].value >
valQuantArr[1].value && memperlakukan >= i) {
if (valQuantArr[0].quant <= memperlakukan) {
valQuantArr[0].nilai--;
memperlakukan -= valQuantArr[0].quant;
valQuantArr = objektifkan(valQuantArr);
}
}
while (valQuantArr[arrayLen - 1].quant <= i && valQuantArr[arrayLen -

1].nilai > valQuantArr[arrayLen - 2].nilai && memperlakukan >= i) {
if (valQuantArr[arrayLen - 1].quant <= memperlakukan) {
valQuantArr[arrayLen - 1].nilai--;
memperlakukan -= valQuantArr[arrayLen - 1].quant;
valQuantArr = objektifkan(valQuantArr);
}
}
}
biarkan hitung = 0;
for (biarkan i = 0, len = valQuantArr.panjang; i < len - 1; i++) {
hitung += Math.abs(valQuantArr[i].nilai - valQuantArr[i + 1].nilai);
}
}
//-----------------pembantu-----------------------
flattenMid = (arr, suguhan, q) => {
biarkan indeks = 0;
while (memperlakukan > 0 && indeks > -1) {
indeks = arr.findIndex((val, ind) => {
return val.quant <= q && ind >= 1 && ind < arr.length - 1 &&
val.value > arr[ind - 1].value && val.value > arr[ind + 1].value;
});
if (indeks >= 0) {
arr[indeks].nilai --;
suguhan -= q;
}
}
kembalikan [objektifikasi(arr), suguhan];
}
//mengubah array menjadi objek dengan nilai sama dengan angka, dan
//quant menjadi berapa kali itu terjadi berturut-turut
objektifikasi = (array) => {
//jika itu adalah array angka
if (typeof array[0] === 'angka') {
biarkan target = [];
biarkan penghitung = 0;
for (biarkan i = 0, len = array.panjang; i < len; i++) {
biarkan val = larik[i];
penghitung++;
if (larik[i] === larik[i + 1]) {
melanjutkan;
} kalau tidak {
target.push({
nilai: larik[i],
kuant: penghitung
});
penghitung = 0;
}
}
target kembali;
} kalau tidak {
//jika itu adalah larik objek, ubah menjadi larik angka, dan
// lalu jalankan melalui metode objektifikasi
biarkan targetArray = [];
array.untukEach (val => {
while (val.quant) {
targetArray.push (val.nilai);
val.quant--;
}
});
return objectify(targetArray);
}
};

FoodDistribution(readline());
biarkan sandwich = parseInt(arr.shift());
// Hasilkan kombo, batasan metode ini, maks 32 sandwich

biarkan kombo = [];
for (biarkan i = 0, max = Math.pow(sandwich+1, arr.length); i < max; i++) {
biarkan kombo = i.toString(sandwich+1);
// Jumlah digit (sandwich) dalam kombo

biarkan comboSum = parseInt(combo.split('').reduce((akumulator, currentValue)
=> akumulator + parseInt(currentValue, sandwiches+1), 0));
// Terlalu banyak sandwich

if (comboSum > sandwich) {
melanjutkan;
}
// Juga dapat menambahkan tanda centang di sini untuk menghapus sandwich yang
akan membuat lapar <0
// Pad combo dari combo yang bagus

while (kombo.panjang < arr.panjang) {
}
if (comboSum <= sandwich) {
kombo.push(kombo);
}
}
// Temukan perbedaan kelaparan terendah

biarkan HungerDifference terendah = null;
combos.forEach(fungsi(kombo){
biarkan testArr = arr.slice();
testArr[i] -= kombo[i];
}
biarkan diff = getHungerDifference(testArr);
terendahHungerDifference = (lowestHungerDifference === null || diff
<lowestHungerDifference) ? diff : HungerDifference terendah;
});
mengembalikan HungerDifference terendah;
fungsi getHungerDifference(arr){
biarkan beda = 0;
diff += Math.abs(arr[i] - arr[i-1]);
}
kembali berbeda;
}

var N = arr[0];
var kelaparanTingkat = arr.slice(1);
sementara (N > 0) {
var maxDifference = 0;
// indeks yang akan diberi sandwich berikutnya
var paling Dibutuhkan = -1;
untuk (var i = 0; i < kelaparanLevels.panjang - 1; i++) {
var perbedaan = Math.abs(Tingkatlapar[i + 1] -Tingkatlapar[i]);
if (perbedaan > perbedaanmaks) {
maxDifference = perbedaan;
paling Dibutuhkan = (Tingkatlapar[i + 1] >Tingkatlapar[i]) ? (i +
1) : i;
}
}
// sekarang kita tahu siapa yang sangat membutuhkan sandwich itu.
memberikannya
jika (paling Dibutuhkan === -1) {
// perbedaan yang berdekatan semuanya 0, jadi berhentilah memberikan
sandwich
kembali 0;
} kalau tidak {
Tingkat kelaparan[paling Dibutuhkan] -= 1;
N--;
}
}
// hitung jumlah perbedaan yang berdekatan

var jumlahPerbedaan = 0;
untuk (var i = 0; i < kelaparanLevels.panjang - 1; i++) {
jumlahPerbedaan += Math.abs(Tingkatlapar[i + 1] -Tingkatlapar[i]);
}
kembalikan jumlahPerbedaan;
}

Tiga Jumlah
Mintalah fungsi ThreeSum( arr ) mengambil larik bilangan bulat yang disimpan dalam arr , dan
tentukan apakah ada tiga angka berbeda (tidak termasuk elemen pertama) dalam larik yang dapat
menjumlahkan elemen pertama dalam larik. Sebagai contoh: jika arr adalah [8, 2, 1, 4, 10, 5, -1, -1]
maka sebenarnya ada tiga set triplet yang berjumlah 8: [2, 1, 5], [4 , 5, -1] dan [10, -1, -1]. Program
Anda harus mengembalikan string true jika 3 elemen berbeda menjumlahkan ke elemen pertama, jika
tidak, program Anda harus mengembalikan string false . Array input akan selalu berisi setidaknya 4
elemen.
Contoh
Masukan: [10, 2, 3, 1, 5, 3, 1, 4, -4, -3, -2]

Keluaran: benar
Masukan: [12, 3, 1, -5, -4, 7]

Keluaran: salah
fungsi TigaJumlah(arr) {
biarkan target = arr.shift();
for (biarkan i = 0; i < len - 2; i++) {
for (biarkan j = i + 1; j < len - 1; j++) {
for (misalkan k = i + 2; k < len; k++) {
if (arr[i] + arr[j] + arr[k] === target) {
kembalikan "benar";
}
}
}
}
kembali "salah"
}

ThreeSum(readline());
biarkan jawaban = parseInt(arr.shift());
// Hasilkan kombo
biarkan kombo = [];
for (biarkan i = 0, max = Math.pow(2, arr.length); i < max; i++) {
biarkan digitSum = parseInt(combo.split('').reduce((akumulator,nilai) =>

akumulator + parseInt(nilai), 0));
if (digitSum !== 3) {
melanjutkan;
}
// Pad digit
while (kombo.panjang < arr.panjang) {
}
kombo.push(kombo);
}
// Uji kombo
biarkan kombo yang baik = [];
biarkan jumlah = 0;
if (kombo[i] === '1') {
jumlah += parseInt(arr[i]);
}
}
if (jumlah === jawaban) {
goodCombos.push(combo);
}
});
return (goodCombos.length > 0) ? benar salah;

var jumlah = arr[0];
var angka = arr.slice(1);
for (var i = 0; i < angka.panjang; i++) {

for (var j = i + 1; j < angka.panjang; j++) {
for (var k = j + 1; k < angka.panjang; k++) {
if (bilangan[i] + bilangan[j] + bilangan[k] === jumlah) {
kembali 'benar';
}
}
}
}
kembali 'salah';
}

Jalan yang Benar
Mintalah fungsi CorrectPath( str ) membaca parameter str yang sedang diteruskan, yang akan
mewakili gerakan yang dilakukan dalam kisi sel 5x5 mulai dari posisi kiri atas. Karakter dalam string
input seluruhnya terdiri dari: r, l, u, d, ? . Masing-masing karakter mewakili arah yang diambil dalam
kisi, misalnya: r = kanan, l = kiri, u = atas, d = bawah. Tujuan Anda adalah untuk menentukan karakter
apa yang harus menjadi tanda tanya agar jalur dibuat dari kiri atas kisi sampai ke kanan bawah tanpa
menyentuh sel yang dilalui sebelumnya di dalam kisi.
Sebagai contoh: jika str adalah "r?d?drdd" maka program Anda harus mengeluarkan string akhir yang
benar yang akan memungkinkan jalur dibentuk dari kiri atas kisi 5x5 ke kanan bawah. Untuk masukan
ini, program Anda harus mengembalikan string rrrdrdd . Hanya akan ada satu jalur yang benar dan akan
selalu ada setidaknya satu tanda tanya dalam string masukan.
Contoh
Masukan: "???rrurdr?"
Keluaran: dddrrrrdrd
Masukan: "drdr??rrddd?"
Keluaran: drdruurrdddd
function CorrectPath(str) {
// buat array untuk menahan posisi tanda tanya
biarkan blankArray = [];
//masukkan posisi tanda tanya ke dalam array
str.split('').forEach((val, ind) => {
if (val === '?') {
blankArray.push(ind);
}
});
biarkan num = blankArray.panjang;
//kita akan mencoba setiap kemungkinan sampai kita menemukan satu yang
berhasil, ini akan menjadi 4^num permutasi
biarkan total = Math.pow(4, num);
for (biarkan i = 0; i < total; i++) {

// telusuri setiap permutasi, pertama-tama buat nomor perwakilan, lalu
buat jalur, lalu uji
biarkan numString = (i + total).toString(4).slice(1);
biarkan currentPath = createPath(str, blankArray, numString);
if (isPathGood(currentPath)) {
mengembalikan CurrentPath;
}
}
}
isPathGood = (str) => {

//buat array kosong kita
biarkan testArray = []
for (biarkan i = 0; i < 5; i++) {
testArray.push([0, 0, 0, 0, 0])
}

biarkan currentLoc = [0, 0];

// tandai kotak kita saat ini sebagai telah dikunjungi
testArray[currentLoc[0]][currentLoc[1]] = 1;
// ubah posisi berdasarkan huruf berikutnya
biarkan newLoc = currentLoc.slice(0);
beralih (str[i]) {
kasus 'u':
newLoc[0]--;
merusak;
kasus 'd':
newLoc[0]++;
merusak;
kasus 'r':
newLoc[1]++;
merusak;
kasus 'l':
newLoc[1]--;
merusak;
}
// berhenti jika kita keluar dari papan
if (newLoc.includes (-1) || newLoc.includes (5)) {
kembali salah;
}
//keluar jika kita berada di tempat yang pernah dikunjungi sebelumnya
if (testArray[newLoc[0]][newLoc[1]] === 1) {
kembali salah;
}
//return true jika kita berada di kotak target pada perjalanan terakhir
kita
if (newLoc[0] === 4 && newLoc[1] === 4 && i === len - 1) {
kembali benar;
}
// perbarui lokasi kami untuk loop berikutnya;
currentLoc = newLoc;
}
kembali salah;
};
createPath = (str, kosong, num) => {

let moveArray = ['r', 'l', 'u', 'd'];
strArr = str.split('');
blanks.forEach((val, ind) => {
strArr.splice(val, 1, moveArray[num[ind]]);
});
return strArr.bergabung('');
};

BenarPath(readline());
biarkan numQmarks = str.split('').reduce((a,v) => a + (v === '?' | 0), 0);
// Hasilkan kombo, 0-r, 1-d, 2-l, 3-u

biarkan kombo = [];
for (biarkan i = 0, max = Math.pow(4, numQmarks); i < max; i++) {
// Pad
while (kombo.panjang < numQmarks) {
}
kombo.push(kombo);
}
biarkan goodPaths = [];
// Coba jalur
biarkan comboArray = combo.split('');
biarkan tryPath = '';
jika (str[i] === '?') {
biarkan arah = comboArray.shift();
beralih (arah) {
huruf '0': // benar
tryPath += 'r';
merusak;
huruf '1': // turun
tryPath += 'd';
merusak;
kasus '2': // kiri
tryPath += 'l';
merusak;
kasus '3': // atas
tryPath += 'u';
merusak;
bawaan:
// Seharusnya tidak pernah terjadi
merusak;
}
} kalau tidak {
tryPath += str[i];
}
}
if (pathGood(tryPath)) {
goodPaths.push(tryPath);
}
});
// goodPaths menurut spesifikasi seharusnya hanya menjadi === 1, tetapi kode ini
dapat menangani lebih banyak kasus yang sebenarnya
kembalikan goodPaths[0];
// Konfirmasi/Tolak jalur yang baik (dengan Qmarks diisi)

function pathGood(path) {
biarkan mulaiX = 0;
biarkan mulaiY = 0;
biarkan kisi = [
[1,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0]
]; // tujuan 4,4
for (biarkan i = 0; i < path.panjang; i++) {

beralih (jalur[i]) {
kasus 'r':
mulaiX++;
merusak;
kasus 'd':
mulaiY++;
merusak;
kasus 'l':
startX--;
merusak;
kasus 'u':
mulaiY--;
merusak;
bawaan:
// Seharusnya tidak pernah terjadi
merusak;
if (mulaiX < 0 || mulaiX > 4 || mulaiY < 0 || mulaiY > 4 || kisi[mulai]

[mulaiX] === 1) {
// sudah bepergian atau keluar batas
kembali salah;
}
kisi[mulaiY][mulaiX] = 1;
}
kembali (mulaiX === 4 && mulaiY === 4) ? benar salah;
}
}

// periksa apakah arah yang diberikan dapat mencapai garis finis

// tanpa menyentuh posisi yang dikunjungi sebelumnya
fungsi canNavigate(str) {
var posisi = [0, 0];
var dikunjungi = {};
beralih(str[i]) {
kasus 'u':
posisi[0]--;
if (position[0] < 0) return false;
merusak;
kasus 'd':
posisi[0]++;
if (position[0] > 4) return false;
merusak;
kasus 'l':
posisi[1]--;
if (position[1] < 0) return false;
merusak;
kasus 'r':
posisi[1]++;
if (position[1] > 4) return false;
merusak;
bawaan:
merusak;
}
if (mengunjungi[posisi[0] + '-' + posisi[1]]) {
// sudah dikunjungi sebelumnya
kembali salah;
} kalau tidak {
// tandai sebagai telah dikunjungi
dikunjungi[posisi[0] + '-' + posisi[1]] = i;
}
}
kembali (posisi[0] === 4 && posisi[1] === 4);

}
fungsi findMissingChars(str) {
// pertama, hasilkan semua kemungkinan kasus: mengganti ? dengan arah
var permutasi = [''];
jika (str[i] === '?') {
var newPermutations = [];
permutasi.untukEach(fungsi(permutasi) {
newPermutations.push(permutasi + 'u');
newPermutations.push(permutasi + 'd');
newPermutations.push(permutasi + 'l');
newPermutations.push(permutasi + 'r');
});
permutasi = Permutasi baru;
} kalau tidak {
permutasi = permutasi.peta(permutasi => permutasi + str[i]);
}
}
// sekarang saring hanya yang valid

// kita membutuhkan hasil bersih 4 down dan 4 right
kembalikan permutasi.filter(fungsi(permutasi) {
var rightCount = permutation.match(/[r]/g) === null ? 0 :
permutasi.cocok(/[r]/g).panjang;
var leftCount = permutation.match(/[l]/g) === null ? 0 :
permutasi.cocok(/[l]/g).panjang;
var upCount = permutation.match(/[u]/g) === null ? 0 :
permutasi.cocok(/[u]/g).panjang;
var downCount = permutation.match(/[d]/g) === null ? 0 :
permutasi.cocok(/[d]/g).panjang;
return (rightCount - leftCount === 4) && (downCount - upCount === 4);

});
}
var validPaths = findMissingChars(str);
untuk (var validPath dari validPaths) {

if (canNavigate(validPath)) {
mengembalikan validPath;
}
}
}

Penyeimbangan Skala
Miliki fungsi ScaleBalancing( strArr ) baca strArr yang akan berisi dua elemen, yang
pertama adalah dua bobot bilangan bulat positif pada skala keseimbangan (sisi kiri dan kanan) dan
elemen kedua adalah daftar bobot yang tersedia sebagai bilangan bulat positif. Sasaran Anda adalah
untuk menentukan apakah Anda dapat menyeimbangkan timbangan dengan menggunakan bobot paling
sedikit dari daftar, tetapi menggunakan paling banyak hanya 2 bobot. Contoh: jika strArr adalah ["[5,
9]", "[1, 2, 6, 7]"] maka ini berarti ada timbangan dengan bobot 5 di sisi kiri dan 9 di sisi kanan .
Sebenarnya dimungkinkan untuk menyeimbangkan skala ini dengan menambahkan 6 ke sisi kiri dari
daftar bobot dan menambahkan 2 ke sisi kanan. Kedua skala sekarang akan sama dengan 11 dan
seimbang sempurna. Program Anda harus mengembalikan string bobot yang dipisahkan koma yang
digunakan dari daftar dalam urutan menaik, jadi untuk contoh ini program Anda harus mengembalikan
string 2,6
Hanya akan ada satu solusi unik dan daftar bobot yang tersedia tidak akan kosong. Dimungkinkan juga
untuk menambahkan dua bobot hanya pada satu sisi timbangan untuk menyeimbangkannya. Jika tidak
memungkinkan untuk menyeimbangkan skala maka program Anda harus mengembalikan string not
possible .
Contoh
Masukan: ["[3, 4]", "[1, 2, 7, 7]"]

Keluaran: 1
Masukan: ["[13, 4]", "[1, 2, 3, 6, 14]"]

Keluaran: 3,6
function ScaleBalancing(strArr) {
// ubah array menjadi sesuatu yang lebih bisa diterapkan
biarkan newArr = strArr.map(val => {
return val.replace(/[\[\]]/g, "").split(',').map(val2 => {
return parseInt(val2, 10);
}).sort((a, b) => {
kembalikan a - b;
});
});
let diff = newArr[0][1] - newArr[0][0];

biarkan bobot = newArr[1];
//lakukan pengujian solusi berbobot tunggal

if (bobot.termasuk(beda)) {
return diff.toString();
}
// lakukan uji dua bobot, satu sisi
biarkan bobot1 = bobot.temukan((val, ind) => {
biarkan bobot baru = bobot.slice(0);
newWeights.splice(ind, 1);
kembalikan bobot baru.termasuk (berbeda - val)
});
jika (berat1) {
kembalikan `${berat1},${perbedaan - berat1}`
}
//lakukan twp-bobot, sisi yang berbeda, tes
weight1 = bobot.temukan(val => {
mengembalikan bobot.termasuk(diff + val);
});
jika (berat1) {
kembalikan `${bobot1},${perbedaan + bobot1}`
}
//jika belum ada yang dikembalikan . . .
mengembalikan `tidak mungkin`;

ScaleBalancing(readline());
biarkan objek = strArr[0].substr(1, strArr[0].panjang-2).split(', ').peta(objek

=> parseInt(objek));
biarkan bobot = strArr[1].substr(1, strArr[1].length-2).split(', ').map(weight =>
parseInt(weight));
/*
Hasilkan semua kemungkinan kombinasi bobot DAN permutasi kiri/kanan - 3^n
kali
0 - Berat tidak digunakan
1 - Berat di sisi kiri
2 - Berat di sisi kanan
*/
biarkan kombo = [];
for (biarkan i = 0, max = Math.pow(3, weights.length); i < max; i++) {
biarkan numWeights = combo.split('').reduce((a,v) => a + (parseInt(v) > 0 |
0), 0);
// Terlalu banyak bobot, buang kombo ini

if (numWeights > 2) {
melanjutkan;
}
// Pad
while (kombo.panjang < bobot.panjang) {
}
kombo.push(kombo);
}
// console.log(kombo);
// Uji kombo
biarkan kombo yang baik = [];
biarkan kiri = objek[0];
biarkan kanan = objek[1];

if (kombo[i] === '1') { // Kiri
kiri += bobot[i];
}
if (kombo[i] === '2') { // Benar
kanan += bobot[i];
}
}
if (kiri === kanan) {

goodCombos.push(combo);
}
});
if (goodCombos.panjang === 0) {
}
// Urutkan dulu berdasarkan jumlah bobot fisik yang digunakan, lalu berdasarkan
bobot total jika ada beberapa set
goodCombos.sort(fungsi(a, b){
biarkan Hitung = a.split('').mengurangi((ac,v) => ac + (parseInt(v) > 0 | 0),
0);
biarkan bHitung = b.split('').mengurangi((ac,v) => ac + (parseInt(v) > 0 |
0), 0);
if (jumlah < jumlah) {

kembali -1;
}
if (hitungan > hitungan) {
kembali 1;
}
// aHitung === bHitung -> harus memeriksa bobot dan menggunakan total bobot
yang lebih rendah
biarkan aTotal = 0;
biarkan bTotal = 0;
for (biarkan i = 0; i < a.panjang; i++) {
jika (a[i] !== '0') {
aTotal += bobot[i];
}
if (b[i] !== '0') {
bTotal += bobot[i];
}
}
kembali aTotal - bTotal;
});
//console.log(Combo bagus);
let theCombo = goodCombos[0];

biarkan bobot akhir = [];
theCombo.split('').peta(fungsi(nilai, indeks) {
if (nilai !== '0') {
finalWeights.push(bobot[indeks]);
}
});
return finalWeights.sort((a,b) => ab).join(',');

}

var bobot = strArr[1].match(/\d+/g).map(Angka);
var weightsOnScale = strArr[0].match(/\d+/g).map(Angka);
var leftWeight = bobotBerdasarkanSkala[0];
var rightWeight = bobotBerdasarkanSkala[1];
// coba hanya satu bobot

for (var i = 0; i < bobot.panjang; i++) {
if (LeftWeight < RightWeight) {
jika (Berat kiri + berat[i] ===Berat kanan)
mengembalikan bobot[i];
} kalau tidak {
if (LeftWeight === RightWeight + bobot[i])
mengembalikan bobot[i];
}
}
// sekarang coba dua beban

for (var i = 0; i < bobot.panjang; i++) {
for (var j = i + 1; j < bobot.panjang; j++) {
// tambahkan satu di setiap sisi
if (Berat kiri + berat[i] ===Berat kanan + berat[j]) {
return bobot[i] + ',' + bobot[j];
} else if (LeatBerat + berat[j] ===Berat kanan + berat[i]) {
}
// tambahkan dua di sisi yang lebih ringan
if (LeftWeight < RightWeight) {
if (Berat kiri + berat[i] + berat[j] ===Berat kanan) {
}
} kalau tidak {
if (BeratBerat ===BeratBerat +Berat[i] +Berat[j]) {
}
}
}
}
// tidak ada solusi

}

Tiga Angka
Mintalah fungsi ThreeNumbers( str ) ambil parameter str yang diteruskan dan tentukan apakah
tepat tiga bilangan bulat satu digit yang unik terjadi di dalam setiap kata dalam string. Bilangan bulat
dapat muncul di mana saja dalam kata, tetapi tidak boleh berdekatan satu sama lain. Jika setiap kata
berisi tepat 3 bilangan bulat unik di suatu tempat di dalamnya, maka kembalikan string true , jika tidak,
kembalikan string false . Sebagai contoh: jika str adalah "2hell6o3 wor6l7d2" maka program Anda
harus mengembalikan "true" tetapi jika string adalah "hell268o w6or2l4d" maka program Anda harus
mengembalikan "false" karena semua bilangan bulat berdekatan satu sama lain di kata pertama.
Contoh
Masukan: "2a3b5 w1o2rl3d g1gg92"

Keluaran: benar
Masukan: "21aa3a ggg4g4g6ggg"

Keluaran: salah
fungsi TigaBilangan(str) {
const DIGITS = '0123456789';
biarkan kata = str.split(' ');
biarkan hasil = null;
kata-kata.untukEach(fungsi(kata){
biarkan angka = 0;
biarkan tigaBerdekatan = salah;
biarkan angkaDigit bekas = '';
for (biarkan i = 0; i < panjang kata; i++) {
// Periksa digit yang digunakan
if (usedDigits.includes(word[i])) {
// digunakan! gagal
hasil = salah;
}
if (DIGITS.termasuk(kata[i])) {
angka++;
usedDigits += kata[i];
if (angka === 3) {
if (DIGITS.termasuk(kata[i-1]) && DIGITS.termasuk(kata[i-2])) {
tigaBerdekatan = benar;
}
}
}
// Periksa 3 digit sebelumnya yang berdekatan
}
if (angka === 3 && !tigaBerdekatan) {

hasil = (hasil === nol) ? benar : hasil && benar;
} kalau tidak {
hasil = salah;
}
});
}

ThreeNumbers(readline());
var kata = str.split(' ');
var numberOfWords = kata.peta(kata => kata.cocok(/\d+/g));
untuk (var jumlah angka Kata) {

// periksa tepat 3 angka di setiap kata
var digit = angka.bergabung('');
if (digits.panjang !== 3)
kembali salah;
// tidak boleh ada 3 angka berturut-turut
if (angka.panjang !== angka.filter(angka => angka.panjang < 3).panjang)
kembali salah;
// tidak boleh ada duplikasi angka pada 3 angka tersebut
if ((angka[0] === angka[1]) ||
(angka[1] === angka[2]) ||
(angka[2] === angka[0]))
kembali salah;
}
kembali benar;
}

biarkan array = str.split(' ');

for (biarkan i = 0; i < array.panjang; i++) {
if (/[0-9]{3,}/.exec(array[i]) !== null) {
kembali salah;
} kalau tidak {
biarkan n = array[i].cocok(/[0-9]/g);
jika (n[0] === n[1] || n[1] === n[2] || n[0] === n[1]) {
kembali salah;
}
}
}
kembali benar;

Pencarian Alfabet
Miliki fungsi AlphabetSearching( str ) ambil parameter str yang diteruskan dan kembalikan
string true jika setiap huruf alfabet bahasa Inggris ada di string, jika tidak, kembalikan string false .
Sebagai contoh: jika str adalah "zacxyjbbkfgtbhdaielqrm45pnsowtuv" maka program Anda harus
mengembalikan string dengan benar karena setiap karakter dalam alfabet ada dalam string ini meskipun
beberapa karakter muncul lebih dari sekali.
Contoh
Masukan: "abcdefghijklmnopqrstuvwxyyyy"
Keluaran: salah
Masukan: "abc123456kmo"
Keluaran: salah
fungsi Pencarian Alfabet(str) {
str = str.toLowerCase();
for (biarkan i = 97; i < 97 + 26; i++) {
biarkan char = String.fromCharCode(i);
if (!str.includes(char)) {
kembali salah;
}
}
kembali benar;
}

Pencarian Alfabet(readline());
const LOWER_LETTERS = 'abcdefghijklmnopqrstuvwxyz';
for (biarkan i = 0; i < LOWER_LETTERS.length; i++) {

if (!str.includes(LOWER_LETTERS[i])) {
kembali salah;
}
}
kembali benar;
}
fungsi isAlpha(char) {
return /[A-Za-z]/.test(char);
}

var foundLetters = [];
if ( isAlpha(str[i]) && (foundLetters.indexOf(str[i]) === -1) ) {
foundLetters.push(str[i]);
}
}
return foundLetters.length === 26;
}

Perbedaan waktu
Buat fungsi TimeDifference( strArr ) membaca larik string yang disimpan di strArr yang
akan menjadi daftar waktu yang tidak disortir dalam format dua belas jam seperti: HH:MM(am/pm).
Tujuan Anda adalah menentukan perbedaan terkecil dalam menit antara dua waktu dalam daftar.
Misalnya: jika strArr adalah ["2:10pm", "1:30pm", "10:30am", "4:42pm"] maka program Anda harus
mengembalikan 40 karena perbedaan terkecil adalah antara 13:30 dan 14:10 dengan selisih 40 menit.
Array input akan selalu berisi setidaknya dua elemen dan semua elemen akan berada dalam format yang
benar dan unik.
Contoh
Masukan: ["1:10 siang", "4:40 pagi", "5:00 sore"]

Keluaran: 230
Masukan: ["10:00", "11:45", "5:00", "12:01"]

Keluaran: 16
function TimeDifference(strArr) {
// waktu akan menahan perbedaan waktu kita
biarkan kali = [];
biarkan newStrArr = strArr.peta (val => {
biarkan cocok = val.cocok(/^(\d+):(\d+)([ap]m)$/);
biarkan jam = parseInt(cocok [1], 10);
biarkan menit = parseInt(cocok[2], 10);
biarkan setengah = cocok[3];
if (setengah === 'pagi' && jam === 12) {
jam = 0;
}
if (setengah === 'siang' && jam !== 12) {
jam += 12;
}
kembali (jam * 60 + menit);
})
.sort((a, b) => { kembalikan a - b});
//tricky - contoh kedua menunjukkan bahwa kita harus mempertimbangkan waktu
paling awal baik pada hari 0 maupun hari 1
newStrArr.push(newStrArr[0] + 24 * 60);
for (biarkan i = 0, len = newStrArr.length; i < len - 1; i ++) {

kali.push(newStrArr[i + 1] - newStrArr[i]);
}
return Math.min.apply(null, times);
}

TimeDifference(readline());
biarkan timesInSeconds = [];

strArr.forEach(fungsi(strWaktu){
biarkan pasangan = strWaktu.split(':');
biarkan jam = (pair[1][2] === 'a') ? parseInt(pasangan[0]) % 12 :
parseInt(pasangan[0]) % 12 + 12;
biarkan detik = parseInt(pair[1].substr(0,2));
biarkan totalSeconds = jam * 60 + detik;
timesInSeconds.push(totalSeconds);
});
// Ulangi lebih dari 2^n kombo

biarkan Perbedaan terkecil = Angka.MAX_VALUE;
for (biarkan i = 0, max = Math.pow(2,timesInSeconds.length); i < max; i++) {
biarkan timesUsed = combo.split('').reduce((a,v) => a + (v === '1' | 0), 0);
if (timesUsed === 2) {
// Pad
while (combo.length < timesInSeconds.length) {
}
// Ulangi setiap kombo tertentu dan ujilah

biarkan beda = 0;
biarkan pasangan = [];
for (biarkan j = 0; j < combo.length; j++) {
if (kombo[j] === '1') {
pair.push(timesInSeconds[j]);
}
}
biarkan t1 = Math.abs(pair[0] - pair[1]);

biarkan t2 = Math.abs(Math.min((1440 - pasangan[0]), (pasangan[0])) +
Math.min((1440 - pasangan[1]), (pasangan[1])));
diff = Math.min(t1, t2);
if (diff < perbedaan terkecil) {

terkecilPerbedaan = perbedaan;
}
}
}
kembalikan perbedaan terkecil;

}

biarkan array = strArr.peta(nilai => {
biarkan cocok = nilai.cocok(/^(\d+):(\d+)([ap]m)$/);
biarkan h = parseInt(cocok [1], 10);
biarkan m = parseInt(cocok[2], 10);
if (cocok[3] === 'am' && h === 12) {
h = 0;
} else if (cocok[3] === 'pm' && h !== 12) {
jam += 12;
}
kembali (60 * h + m);
}).sort(fungsi(a, b) {
kembalikan a - b;
});
array.push(array[0] + 24 * 60);
biarkan kali = [];
for (biarkan i = 0; i < array.panjang - 1; i++) {
kali.push(array[i+1] - larik[i]);
}
return Math.min(... kali);
}
Baris Segitiga
Miliki fungsi TriangleRow( num ) ambil num yang akan menjadi bilangan bulat positif yang
mewakili beberapa baris dari segitiga Pascal. Segitiga Pascal dimulai dengan [1] di baris ke-0 segitiga.
Maka baris pertama adalah [1, 1] dan baris kedua adalah [1, 2, 1]. Baris berikutnya dimulai dengan 1 dan
diakhiri dengan 1, dan bagian dalam baris ditentukan dengan menjumlahkan elemen k-1 dan kth dari
baris sebelumnya. Baris berikutnya dalam segitiga akan menjadi [1, 3, 3, 1], dan seterusnya. Inputnya
akan berupa bilangan bulat positif dan tujuan Anda adalah mengembalikan jumlah baris itu. Misalnya:
jika num adalah 4 maka program Anda harus mengembalikan jumlah 1 + 4 + 6 + 4 + 1 yaitu 16 .
Contoh
Masukan: 1
Keluaran: 2
Masukan: 2
Keluaran: 4
fungsi SegitigaBaris(bil) {
return Math.pow(2, num);
}
console.log(TriangleRow(5));

TriangleRow(readline());
misalkan segitiga = [];

for (biarkan baris = 0; baris <= num; baris++) {
biarkan barisArr = [];
for (biarkan i = 0; i <= baris; i++) {
jika (saya === 0) {
rowArr.push(1);
melanjutkan;
}
biarkan delta = (i < segitiga[baris-1].panjang) ? segitiga[baris-1][i] :
0;
rowArr.push(segitiga[baris-1][i-1] + delta);
}
segitiga.push(rowArr);
}
return segitiga[num].reduce((a,v) => a + v,0);
}
// dapatkan baris ke-n dan kolom ke-k dari segitiga pascal

fungsi pascalSegitiga(n, k) {
jika (n === 0) kembalikan 1;
jika (k === 0 || k === n) kembalikan 1;
return pascalSegitiga(n - 1, k - 1) + pascalSegitiga(n - 1, k);
}
// jawaban yang mudah - selalu berjumlah n^2
// kembalikan num * num;
// dengan cara yang sulit

varJumlahbaris = 0;
untuk (k = 0; k <= num; k++) {
hasil = pascalSegitiga(bil, k);
jumlahbaris += hasil;
}
kembali jumlah baris;
}

Kotak Vokal
Mintalah fungsi VowelSquare( strArr ) ambil parameter strArr yang akan menjadi matriks 2D
dengan ukuran acak yang diisi dengan huruf dari alfabet, dan tentukan apakah persegi 2x2 yang
seluruhnya terdiri dari vokal ada dalam matriks. Misalnya: strArr adalah ["abcd", "eikr", "oufj"] maka
matriks ini terlihat seperti berikut:
abcd
ei kr
ou fj
Di dalam matriks ini terdapat bujur sangkar vokal 2x2 yang dimulai dari baris kedua dan kolom
pertama, yaitu ei, ou. Jika 2x2 kotak vokal ditemukan, program Anda harus mengembalikan posisi kiri
atas (baris-kolom) kotak, jadi untuk contoh ini program Anda harus mengembalikan 1-0 . Jika tidak ada
kuadrat vokal 2x2, maka kembalikan string not found . Jika ada beberapa kotak vokal, kembalikan yang
berada di posisi paling kiri atas di seluruh matriks. Matriks input setidaknya berukuran 2x2.
Contoh
Masukan: ["aqrst", "ukaei", "ffooo"]

Keluaran: 1-2
Masukan: ["gg", "ff"]

Keluaran: tidak ditemukan
function VowelSquare(strArr) {
strArr = strArr.peta(val => {
return val.toLowerCase().replace(/[aeiou]/g, "!");
})
for (misalkan r = 0, len = strArr.panjang; r < len - 1; r++) {
for (biarkan c = 0, len = strArr[0].length; c < len - 1; c++) {
if (checkPoint(strArr, [r, c])) {
return `${r}-${c}`;
}
}
}
kembali 'tidak ditemukan'
fungsi checkPoint(arr, titik) {

console.log('arr', arr[titik[0]][titik[1]]);
console.log('titik', titik);
kembali (
arr[titik[0]][titik[1]] === '!' &&
arr[titik[0] + 1][titik[1]] === '!' &&
arr[titik[0]][titik[1] + 1] === '!' &&
arr[titik[0] + 1][titik[1] + 1] === '!'
)
}

VowelSquare(readline());
untuk (biarkan baris = 0; baris < strArr.panjang-1; baris++) {

for (biarkan col = 0; col < strArr[0].panjang-1; col++) {
if (isVowels2x2(strArr, baris, kolom)) {
// Bagus! Kembalikan yang pertama karena kami
// cari dalam urutan yang baik
kembali baris + '-' + col;
}
}
}
kembali 'tidak ditemukan';
function isVowels2x2(strArr, baris, kolom) {

// Bisa melakukan pemeriksaan batas di sini tetapi dilakukan di main()
if (!isVowel(strArr[baris][kolom])) return false;

if (!isVowel(strArr[baris+1][kolom])) return false;
if (!isVowel(strArr[row][col+1])) return false;
if (!isVowel(strArr[baris+1][col+1])) return false;
kembali benar;
}
function isVowel(huruf) {
const VOWEL = 'aeiou';
return VOwels.includes(letter);
}
}

// periksa apakah setiap huruf dalam matriks yang diberikan adalah vokal
function allVowels(matrix) {
return matrix.every(row => row.every(letter => 'aeiou'.indexOf(letter) !== -1));
}
var matriks = strArr.peta(baris => baris.split(''));
for (var baris = 0; baris < matriks.panjang - 1; baris++) {

for (var kolom = 0; kolom < matriks[0].panjang - 1; kolom++) {
// uji dengan jendela geser sub-matriks 2x2
var subMatrix = matrix.slice(baris, baris + 2).map(rowArr =>
rowArr.slice(kolom, kolom + 2));
if (semuaVokal(subMatrix)) {
kembali baris + '-' + kolom;
}
}
}
kembali 'tidak ditemukan';

}

Musuh Terdekat
Miliki fungsi ClosestEnemy( arr ) ambil larik angka yang disimpan di arr dan dari posisi dalam
larik di mana 1 berada, kembalikan jumlah spasi baik kiri atau kanan Anda harus bergerak untuk
mencapai musuh yang diwakili oleh 2. Misalnya: jika arr adalah [0, 0, 1, 0, 0, 2, 0, 2] maka program
Anda harus mengembalikan 3 karena musuh terdekat (2) berjarak 3 spasi dari 1. Array akan berisi
sejumlah 0 dan 2, tetapi hanya 1 tunggal. Itu mungkin tidak mengandung 2 sama sekali, di mana dalam
hal ini program Anda harus mengembalikan 0.
Contoh
Masukan: [1, 0, 0, 0, 2, 2, 2]
Keluaran: 4
Masukan: [2, 0, 0, 0, 2, 2, 1, 0]
Keluaran: 1
function ClosestEnemy(arr) {
if (!arr.includes(2)) {
kembali 0;
}
loc1 = arr.findIndex(val => {
kembali nilai === 1;
});
for (biarkan i = 1, len = arr.panjang; i < len; i++) {

if (arr[loc1 + i] === 2 || arr[loc1 - i] === 2) {
kembalikan saya;
}
}
kembalikan lokasi1;
}

Musuh Terdekat(readline());
biarkan pahlawan = -1;

if (arr[i] === 1) { // Menemukan pahlawan
pahlawan = saya;
}
}
// Cari dengan benar

biarkan deltaRight = tidak terdefinisi;
for (biarkan i = hero+1; i < arr.length; i++) {
if (arr[i] === 2) { // Menemukan musuh
deltaRight = i - pahlawan;
merusak;
}
}
// Cari di kiri
biarkan deltaLeft = undefined;
for (biarkan i = hero-1; i >= 0; i--) {
if (arr[i] === 2) { // Menemukan musuh
deltaLeft = pahlawan - i;
merusak;
}
}
if (deltaLeft === tidak terdefinisi && deltaRight === tidak terdefinisi) {
kembali 0;
}
if (deltaLeft === tidak terdefinisi) {

kembalikan deltaRight;
}
if (deltaRight === tidak terdefinisi) {

kembali deltaLeft;
}
kembali (deltaLeft < deltaRight) ? deltaLeft : deltaKanan;

}

// indeks 1
var saya = arr.indexOf(1);
var jarak minimum = arr.panjang;

jika (arr[i] === 2) {
var jarak = Math.abs(i - saya);
if (jarak <jarak minimum) {
Jarak minimum = jarak;
}
}
}
return (minimumDistance === arr.length) ? 0 : Jarak minimum;

}

Musuh Terdekat II
Memiliki fungsi ClosestEnemyII( strArr ) membaca matriks angka yang disimpan dalam
strArr yang akan menjadi matriks 2D yang hanya berisi bilangan bulat 1, 0, atau 2. Kemudian dari
posisi dalam matriks dimana 1 berada, kembalikan jumlah spasi baik kiri, kanan, bawah, atau atas Anda
harus bergerak untuk mencapai musuh yang diwakili oleh 2. Anda juga dapat membungkus satu sisi
matriks ke sisi lainnya. Sebagai contoh: jika strArr adalah ["0000", "1000", "0002", "0002"] maka
akan terlihat seperti berikut:
0 0 0 0
1 0 0 0
0 0 0 2
0 0 0 2
Untuk input ini program Anda harus mengembalikan 2 karena musuh terdekat (2) berjarak 2 spasi dari 1
dengan bergerak ke kiri untuk membungkus ke sisi lain dan kemudian bergerak ke bawah sekali. Array
akan berisi sejumlah 0 dan 2, tetapi hanya 1 tunggal. Itu mungkin tidak mengandung 2 sama sekali, di
mana dalam hal ini program Anda harus mengembalikan 0.
Contoh
Masukan: ["000", "100", "200"]

Keluaran: 1
Masukan: ["0000", "2010", "0000", "2002"]

Keluaran: 2
function ClosestEnemyII(strArr) {
//langkah pertama - kembalikan 0 jika tidak ada 2 dalam array
biarkan twosies = strArr.filter(val => {
return val.include("2");
});
if (!duasies.panjang) {
kembali 0;
}
//langkah kedua - dapatkan koordinat 1 (targetX, targetY)
targetY = strArr.findIndex(val => {
return val.include('1');
});
targetX = strArr[targetY].search(/1/);
//langkah ketiga temukan jalur terkecil ke 2
biarkan res = strArr.panjang * strArr[0].panjang;
for (biarkan baris = 0, len = strArr[0].panjang; baris < len; baris++) {

for (col = 0, tinggi = strArr.panjang; col < tinggi; col++) {
if (strArr[baris][kolom] === '2') {
xShift = barisDist(targetX, col, len);
yShift = barisDist(targetY, baris, tinggi);
res = Math.min(res, xShift + yShift);
}
}
}
kembalikan res;
}
//-----------------------pembantu-------------------------
// terlepas dari namanya, gunakan untuk jarak kolom dan baris
fungsi barisDist(y, x, len) {
return Math.min(Math.abs(x - y), Math.abs(y - x + len));
}

ClosestEnemyII(readline());
// Temukan pahlawan
biarkan pahlawanY = -1;
biarkan heroX = -1;
biarkan hasil = strArr[i].indexOf(1);
if (hasil > -1) {
heroX = hasil;
pahlawanY = saya;
}
}
if (heroY === -1) {

// Tidak ada pahlawan
kembali -1;
}
//console.log(heroY + '-' + heroX);
// Periksa musuh
biarkan musuh = [];
biarkan hasil = strArr[i].indexOf(2);
if (hasil > -1) {
musuh.push([i, hasil]);
}
}
if (musuh.panjang === 0) {
kembali 0;
}
//console.log(musuh);
biarkan terdekatJarak = Angka.MAX_SAFE_INTEGER;
// Memeriksa jarak musuh

for (biarkan i = 0; i < musuh.panjang; i++) {
biarkan musuhX = musuh[i][1];
biarkan musuhY = musuh[i][0];
biarkan deltaX = Math.abs(musuhX - heroX);

biarkan deltaY = Math.abs(musuhY - heroY);
//console.log(deltaY + '-' + deltaX);
// Sekarang periksa nilai wrap-around

// deltaX adalah maks karena jika lebih maka kami tidak peduli
biarkan wrapDeltaX = Number.MAX_SAFE_INTEGER;
for (biarkan i = 0; i < deltaX; i++) {
if ((musuhX + i) % strArr[0].panjang === heroX) {
// menemukan delta pahlawan
bungkusDeltaX = saya;
//console.log('wrap-aroundX: ' + i)
}
}
biarkan wrapDeltaY = Number.MAX_SAFE_INTEGER;

for (biarkan i = 0; i < deltaY; i++) {
if ((musuhY + i) % strArr.panjang === heroY) {
// menemukan delta pahlawan
bungkusDeltaY = saya;
//console.log('wrap-aroundY: ' + i)
}
}
deltaX = (wrapDeltaX < deltaX) ? bungkusDeltaX : deltaX;

deltaY = (wrapDeltaY < deltaY) ? bungkusDeltaY : deltaY;
misalkan jarak = deltaX + deltaY;
if (jarak <jarak terdekat) {

jarak terdekat = jarak;
}
}
kembali terdekatJarak;

// temukan jarak antara dua elemen dengan indeks [baris, kolom] yang diberikan
fungsi getDistance(matrixSize, indeks1, indeks2) {
var barisJarak = Math.min(Math.abs(indeks2[0] - indeks1[0]), Math.abs(indeks1[0]
- (indeks2[0] - ukuranmatriks)));
var columnDistance = Math.min(Math.abs(indeks2[1] - indeks1[1]),
Math.abs(indeks1[1] - (indeks2[1] - ukuranmatriks)));
kembali barisJarak + jarakkolom;
}
var matriks = strArr.peta(baris => baris.split('').peta(Angka));
var minDistance = matriks.panjang * 2;
// lokasi saya: 1
var meIndeks;
// lokasi musuh: 2
var musuhIndeks = [];
// mengidentifikasi lokasi 1 dan 2

for (var baris = 0; baris < matriks.panjang; baris++) {
for (var kolom = 0; kolom < matriks[0].panjang; kolom++) {
if (matriks[baris][kolom] === 1) {
meIndices = [baris, kolom];
} else if (matriks[baris][kolom] === 2) {
enemyIndices.push([baris, kolom]);
}
}
}
// periksa jarak dariku untuk setiap musuh

for (var enemyIndices of enemyIndices) {
var distance = getDistance(matrix.length, meIndices, enemyIndices);
if (jarak < jarak min) {
minJarak = jarak;
}
}
// menangani kasus dimana tidak ada musuh

return minDistance === matrix.length * 2 ? 0 : jarak min;
}

Aliran Angka
Mintalah fungsi NumberStream( str ) mengambil parameter str yang akan berisi angka 2 hingga
9, dan tentukan apakah ada aliran digit berturut-turut dengan panjang minimal N di mana N adalah nilai
digit sebenarnya. Jika demikian, kembalikan string true , jika tidak kembalikan string false . Sebagai
contoh: jika str adalah "6539923335" maka program Anda harus mengembalikan string yang benar
karena ada aliran 3 yang berurutan dengan panjang 3. String input akan selalu berisi setidaknya satu
digit.
Contoh
Masukan: "5556293383563665"
Keluaran: salah
Masukan: "5788888888882339999"
Keluaran: benar
fungsi NumberStream(str) {
for (biarkan i = 2; i < 10; i++) {
biarkan iChar = i.toString();
biarkan jarum = iChar.repeat(i);
if (str.indexOf(jarum) !== -1) {
kembali benar;
}
}
// kode di sini
kembali salah;

NumberStream(readline());
for (misalkan i = 0, lastDigit = -1, count = 0; i < str.length; i++) {

if (str[i] === digitterakhir) {
// Streaming berlanjut
hitung++;
if (hitung >= Angka(DigitAkhir)) {
kembali benar;
}
} kalau tidak {
// Aliran baru
angkaterakhir = str[i];
hitungan = 1;
}
}
kembali salah;
}

// hasilkan pola terlebih dahulu
pola var = [];
untuk (var i = 1; i < 10; i++) {
pola.push(String(i).ulangi(i));
}
untuk (var pola pola) {

if (str.indexOf(pattern) !== -1) {
// pola ditemukan
kembali benar;
}
}
kembali salah;
}

Empat Terbesar
Mintalah fungsi LargestFour( arr ) ambil array bilangan bulat yang disimpan di arr , dan
temukan empat elemen terbesar dan kembalikan jumlahnya. Sebagai contoh: jika arr adalah [4, 5, -2, 3,
1, 2, 6, 6] maka empat elemen terbesar dalam array ini adalah 6, 6, 4, dan 5 dan jumlah total angka-
angka ini adalah 21 , jadi program Anda harus mengembalikan 21 . Jika ada kurang dari empat angka
dalam larik, program Anda harus mengembalikan jumlah semua angka dalam larik.
Contoh
Masukan: [1, 1, 1, -5]

Keluaran: -2
Masukan: [0, 0, 2, 3, 7, 1]
Keluaran: 13
function LargestFour(arr) {
biarkan newArr = arr.sort((val1, val2) => {
kembalikan val2 - val1;
})
.splice(0, 4);
return newArr.reduce((val1, val2) => {
kembalikan val1 + val2;
}, 0);
}

LargestFour(readline());
return arr.sort((a,b) => ba).reduce((a,v,i) => a + ((i < 4) ? v : 0), 0);

return arr.sort((a, b) => a < b).slice(0, 4).reduce((sum, v) => sum + v, 0);
}

Karakter yang Berbeda
Mintalah fungsi DistinctCharacters( str ) ambil parameter str yang diteruskan dan tentukan
apakah mengandung setidaknya 10 karakter berbeda, jika demikian, maka program Anda harus
mengembalikan string true , jika tidak maka harus mengembalikan string false . Misalnya: jika str
adalah "abc123kkmmmm?" maka program Anda harus mengembalikan string false karena string ini
hanya berisi 9 karakter berbeda: a, b, c, 1, 2, 3, k, m, ? menambahkan hingga 9.
Contoh
Masukan: "12334bbmma:=6"
Keluaran: benar
Masukan: "eeeemmmmmmmmm1000"
Keluaran: salah
function DistinctCharacters(str) {
biarkan mySet = new Set(str.split(''));
kembalikan mySet.size >= 10 ? benar salah
}

DistinctCharacters(readline());
biarkan charCodes = [];
if (!charCodes.includes(str.charCodeAt(i))) {
charCodes.push(str.charCodeAt(i));
}
}
return (charCodes.length >= 10) ? benar salah;

var perbedaan = {};

perbedaan[str[i]] = '';
}
return Object.keys(distincts).length >= 10;

}

Tanda Tanya
Miliki fungsi Tanda Tanya( str ) ambil parameter string str , yang akan berisi angka satu digit,
huruf, dan tanda tanya, dan periksa apakah ada tepat 3 tanda tanya di antara setiap pasangan dari dua
angka yang berjumlah 10. Jika demikian, maka program Anda harus mengembalikan string true , jika
tidak program Anda harus mengembalikan string false . Jika tidak ada dua angka yang menambahkan
hingga 10 dalam string, maka program Anda juga harus mengembalikan false .
Sebagai contoh: jika str adalah "arrb6???4xxbl5???eee5" maka program Anda harus mengembalikan
nilai true karena tepat ada 3 tanda tanya antara 6 dan 4, dan 3 tanda tanya antara 5 dan 5 di akhir string.
Contoh
Masukan: "aa6?9"
Keluaran: salah
Masukan: "acc?7??sss?3rr1????????5"
Keluaran: benar
function Tanda Tanya(str) {
biarkan numPlaces = [];
// anggapan salah, sampai bendera berubah menjadi benar
biarkan bendera = salah;
// dapatkan array tempat dalam string yang menyimpan bilangan bulat

for (biarkan i = 0, len = str.panjang; i < len; i++) {
if (/\d/.test(str[i])) {
numPlaces.push(i);
}
}
biarkan numCount = numPlaces.panjang;
for (biarkan i = 0; i < numCount - 1; i++) {

if (parseInt(str[numPlaces[i]], 10) + parseInt(str[numPlaces[i + 1]],
10) === 10) {
bendera = benar;
biarkan strSeg = str.slice(numPlaces[i], numPlaces[i + 1]);
strSeg = strSeg.ganti(/[^\?]/g, '');

if (strSeg !== '???') {
kembali salah;
}
}
}
bendera kembali;
}

Tanda Tanya(readline());
Kasus Unta
Memiliki fungsi CamelCase( str ) mengambil parameter str yang diteruskan dan
mengembalikannya dalam format huruf besar unta yang tepat di mana huruf pertama dari setiap kata
dikapitalisasi (tidak termasuk huruf pertama). String hanya akan berisi huruf dan beberapa kombinasi
karakter tanda baca pembatas yang memisahkan setiap kata.
Misalnya: jika str adalah "BOB love-coding" maka program Anda harus mengembalikan string
bobLovesCoding .
Contoh
Input: "kucing DAN * Anjing-aneh"

Keluaran: kucingDanAnjingLuar Biasa
Masukan: "abc def%g"

Keluaran: aBCDEFG
function CamelCase(str) {
biarkan strArr = str.split(/[â-zA-Z]/);
strArr = strArr.map((val, ind) => {
val = val.toLowerCase();
saya menemukan) {
valArr = val.split('');
valArr[0] = valArr[0].toUpperCase();
return valArr.join('');
}
nilai kembali;
})
return strArr.bergabung('');
}

CamelCase(readline());
Konversi ASCII
Mintalah fungsi ASCIIConversion( str ) mengambil parameter str yang diteruskan dan
mengembalikan string baru di mana setiap karakter, selain karakter spasi, diganti dengan kode karakter
desimal yang sesuai. Sebagai contoh: jika str adalah "anjing" maka program Anda harus
mengembalikan string 100111103 karena d = 100, o = 111, g = 103.
Contoh
Masukan: "halo dunia"

Keluaran: 104101108108111 119111114108100
Masukan: "abc **"

Keluaran: 979899 4242
function ASCIIConversion(str) {
biarkan myArr = str.split(' ').map(val => {
return val.split('').peta(val2 => {
kembalikan val2.charCodeAt(0);
}).bergabung('')
}).bergabung(' ');
kembalikan myArr;
}

ASCIIConversion(readline());
Genap Sederhana
Miliki fungsi SimpleEvens( num ) periksa apakah setiap angka dalam parameter yang diteruskan
adalah genap. Jika demikian, kembalikan string true , jika tidak kembalikan string false . Sebagai
contoh: jika num adalah 4602225, program Anda harus mengembalikan string false karena 5 bukan
bilangan genap.
Contoh
Masukan: 2222220222
Keluaran: benar
Masukan: 20864646452
Keluaran: salah
function SimpleEvens(num) {
kembalikan num.toString(10).search(/[13579]/) === -1 ? 'benar salah';
}
SimpleEvens(readline());
Kasus Ular
Memiliki fungsi SnakeCase( str ) mengambil parameter str yang diteruskan dan
mengembalikannya dalam format kasus ular yang tepat di mana setiap kata ditulis dengan huruf kecil
dan dipisahkan dari kata yang berdekatan melalui garis bawah. String hanya akan berisi huruf dan
beberapa kombinasi karakter tanda baca pembatas yang memisahkan setiap kata.
Misalnya: jika str adalah "BOB love-coding" maka program Anda harus mengembalikan string
bob_loves_coding .
Contoh
Input: "kucing DAN * Anjing-aneh"

Keluaran: cat_and_dogs_are_awesome
Masukan: "abc def%g"

Keluaran: a_b_c_d_e_f_g
function SnakeCase(str) {
return str.split(/[â-zA-Z]/).map(val => {return
val.toLowerCase()}).join('_');
}
SnakeCase(readline());
Temukan Persimpangan
Buat fungsi FindIntersection( strArr ) membaca larik string yang disimpan dalam strArr
yang akan berisi 2 elemen: elemen pertama akan mewakili daftar nomor yang dipisahkan koma yang
diurutkan dalam urutan menaik, elemen kedua akan mewakili daftar kedua yang dipisahkan koma nomor
(juga diurutkan). Tujuan Anda adalah mengembalikan string yang dipisahkan koma yang berisi angka
yang muncul di elemen strArr dalam urutan terurut. Jika tidak ada persimpangan, kembalikan string
false .
Sebagai contoh: jika strArr berisi ["1, 3, 4, 7, 13", "1, 2, 4, 13, 15"] output harus mengembalikan
"1,4,13" karena angka tersebut muncul di kedua string. Larik yang diberikan tidak akan kosong, dan
setiap string di dalam larik akan berupa angka yang diurutkan dalam urutan menaik dan mungkin berisi
angka negatif.
Contoh
Masukan: ["1, 3, 4, 7, 13", "1, 2, 4, 13, 15"]

Keluaran: 1,4,13
Masukan: ["1, 3, 9, 10, 17, 18", "1, 4, 9, 10"]

Keluaran: 1,9,10
function FindIntersection(masukan) {
const [DaftarPertama,DaftarKedua] = input.peta( s => s.split(", ") );
const resultMap = {};

hasil const = [];
for ( nomor const dari firstList ) {

resultMap[ angka ] = true;
}
for ( nomor const dari SecondList ) {

jika ( resultMap[angka] ) {
result.push(angka);
}
}
kembali result.length ? result.join(",") : false;

}

console.log(FindIntersection(readline()));
Pengganda Jumlah
Miliki fungsi SumMultiplier( arr ) ambil larik angka yang disimpan di arr dan kembalikan
string benar jika ada dua angka yang dapat dikalikan sehingga jawabannya lebih dari dua kali lipat
jumlah semua elemen dalam larik. Jika tidak, kembalikan string false . Misalnya: jika arr adalah [2, 5,
6, -6, 16, 2, 3, 6, 5, 3] maka jumlah semua elemen ini adalah 42 dan digandakan menjadi 84. Ada dua
elemen dalam array, 16 * 6 = 96 dan 96 lebih besar dari 84, jadi program Anda harus mengembalikan
string true .
Contoh
Masukan: [2, 2, 2, 2, 4, 1]
Keluaran: salah
Masukan: [1, 1, 2, 10, 3, 1, 12]

Keluaran: benar
function SumMultiplier(arr) {
const target = arr.reduce((val1, val2) => val1 + val2, 0) * 2;
arr.sort((bil1, num2) => num1 - num2);
const len = arr.panjang;
pemeriksa const = Math.max((arr[0] * arr[1]), (arr[len - 2] * arr[len - 1]));
pemeriksa kembali > target;
}
SumMultiplier(readline());
Penggabungan Tali
Perintahkan fungsi StringMerge( str ) membaca parameter str yang sedang diteruskan yang akan
berisi string besar karakter alfanumerik dengan satu karakter asterisk yang membagi string secara merata
menjadi dua string terpisah. Tujuan Anda adalah mengembalikan string baru dengan memasangkan
karakter di lokasi yang sesuai di kedua string. Sebagai contoh: jika str adalah "abc1*kyoo" maka
program Anda harus mengembalikan string akbyco1o karena a berpasangan dengan k, b berpasangan
dengan y, dll. Tali akan selalu terbelah rata dengan tanda bintang di tengah.
Contoh
Masukan: "aaa*bbb"
Keluaran: abab
Masukan: "123hg*aaabb"
Keluaran: 1a2a3ahbgb
fungsi StringMerge(str) {
const cleanString = str.replace(/[^\w*]/g, '');
const len = (cleanString.panjang - 1) / 2;
const arr = str.split('*');

stringbaru += arr[0][i] + arr[1][i];
}
}

StringMerge(readline());
Satu Dikurangi
Miliki fungsi OneDecremented( str ) hitung berapa kali angka yang muncul tepat satu kurang dari
angka sebelumnya. Sebagai contoh: jika str adalah "5655984" maka program Anda harus
mengembalikan 2 karena 5 muncul langsung setelah 6 dan 8 muncul langsung setelah 9. Input akan
selalu berisi minimal 1 digit.
Contoh
Masukan: "56"
Keluaran: 0
Masukan: "9876541110"
Keluaran: 6
function OneDecremented(num) {
biarkan arr = num.toString().split('');
jika (parseInt(val, 10) - parseInt(arr[ind + 1], 10) === 1) {
penghitung++;
}
})
loket pengembalian;
}

OneDecremented(readline());
Penggabungan Elemen
Mintalah fungsi ElementMerger( arr ) ambil larik bilangan bulat positif yang disimpan dalam arr
dan lakukan algoritme berikut: terus dapatkan selisih bilangan bulat yang berdekatan untuk membuat
larik bilangan bulat baru, lalu lakukan hal yang sama untuk larik baru hingga satu angka kiri dan kembali
nomor itu. Sebagai contoh: jika arr adalah [4, 5, 1, 2, 7] maka mengambil perbedaan dari setiap
pasangan elemen menghasilkan array baru berikut: [1, 4, 1, 5]. Kemudian lakukan hal yang sama untuk
array baru ini untuk menghasilkan [3, 3, 4] -> [0, 1] -> 1. Jadi untuk contoh ini program Anda harus
mengembalikan angka 1 karena itulah yang tersisa di akhir.
Contoh
Masukan: [5, 7, 16, 1, 2]

Keluaran: 7
Masukan: [1, 1, 1, 2]
Keluaran: 1
function ElementMerger(arr) {
jika (arr.panjang === 1) {
return arr[0];
} kalau tidak {
newArr = [];
if (ind < arr.panjang - 1) {
newArr.push(Math.abs(val - arr[ind + 1]));
}
})
return ElementMerger(newArr);
}
}
ElementMerger(readline());
GCF
Mintalah fungsi GCF( arr ) mengambil larik angka yang disimpan dalam arr yang akan selalu berisi
hanya dua bilangan bulat positif, dan mengembalikan faktor persekutuan terbesarnya. Misalnya: jika
arr adalah [45, 12] maka program Anda harus mengembalikan 3 . Akan selalu ada dua elemen dalam
array dan mereka akan menjadi bilangan bulat positif.
Contoh
Masukan: [1, 6]
Keluaran: 1
Masukan: [12, 28]

Keluaran: 4
fungsi GCF(arr) {
biarkan res = null;
biarkan maks = Math.max(...arr);
biarkan min = Math.min(...arr);
for (biarkan i = 1; i <= min; i++) {
jika (maks % i === 0 && min % i === 0) {
res = saya;
}
}
kembalikan res;
}

GCF(garis baca());
Nomor seri
Minta fungsi SerialNumber( str ) ambil parameter str yang diteruskan dan tentukan apakah itu
nomor seri yang valid dengan batasan berikut:
1. Itu harus berisi tiga set masing-masing dengan tiga digit (1 sampai 9) yang dipisahkan oleh titik.
2. Himpunan digit pertama harus berjumlah genap.
3. Kumpulan digit kedua harus berjumlah ganjil.
4. Digit terakhir di setiap set harus lebih besar dari dua digit sebelumnya di set yang sama.
Jika semua batasan di atas terpenuhi dalam string, program Anda harus mengembalikan string true , jika
tidak, program Anda harus mengembalikan string false . Sebagai contoh: jika str adalah "224.315.218"
maka program Anda harus mengembalikan "true".
Contoh
Masukan: "11.124.667"
Keluaran: salah
Masukan: "114.568.112"
Keluaran: benar
fungsi Nomor Seri(str) {

// periksa format string
biarkan tujuan = /^\d{3}\.\d{3}\.\d{3}$/
if (!goal.test(str)) {
kembali 'salah';
}
//ubah string menjadi tiga larik yang masing-masing terdiri dari tiga digit
biarkan arr = str.split(/\./).map(val => {
return val.split('').peta(val2 => {
return parseInt(val2, 10);
});
});
//periksa kondisi satu

if ((arr[0][0] + arr[0][1] + arr[0][2]) % 2) {
kembali 'salah';
}
// periksa kondisi dua

jika (!((arr[1][0] + arr[1][1] + arr[1][2]) % 2)) {
kembali 'salah';
}
//periksa kondisi tiga

for (biarkan i = 0, len = arr.panjang; i < len; i++) {
if (Math.max(...arr[i]) !== arr[i][2]) {
kembali 'salah';
}
}
//jika semua kondisi lulus tanpa salah, maka kembalikan benar
kembali benar;
}
SerialNumber(readline());
Periode Rangkaian
Mintalah fungsi StringPeriods( str ) mengambil parameter str yang diteruskan dan menentukan
apakah ada beberapa substring K yang dapat diulang N > 1 kali untuk menghasilkan string input persis
seperti yang terlihat. Program Anda harus mengembalikan substring terpanjang K, dan jika tidak ada, ia
harus mengembalikan string -1 .
Sebagai contoh: jika str adalah "abcababcababcab" maka program Anda harus mengembalikan abcab
karena itu adalah substring terpanjang yang diulang 3 kali untuk membuat string terakhir. Contoh lain:
jika str adalah "abababababab" maka program Anda harus mengembalikan ababab karena merupakan
substring terpanjang. Jika input string hanya berisi satu karakter, program Anda harus mengembalikan
string -1 .
Contoh
Masukan: "abcxabc"
Keluaran: -1
Masukan: "affedaaffed"
Keluaran: -1
function StringPeriods(str) {
// kita hanya akan menggunakan panjang substring yang terbagi rata menjadi str
const len = str.panjang;
const pivot = Math.max(Math.trunc(Math.sqrt(len)), len);
for (biarkan i = 2; i <= pivot; i++) {
jika (len % i === 0) {
blok const = str.slice(0, len / i);
if (blok.ulangi(i) === str) {
blok kembali;
}
}
}
kembali -1;
}

StringPeriods(readline());
Penukar Palindrom
Miliki fungsi PalindromeSwapper( str ) ambil parameter str yang diteruskan dan tentukan
apakah palindrome dapat dibuat dengan menukar dua karakter yang berdekatan dalam string. Jika
memungkinkan untuk membuat palindrom, maka program Anda harus mengembalikan palindrom, jika
tidak maka kembalikan string -1 . String input hanya akan berisi karakter alfabet. Sebagai contoh: jika
str adalah "rcaecar" maka Anda dapat membuat palindrom dengan menukar karakter kedua dan ketiga,
sehingga program Anda harus mengembalikan string racecar yang merupakan string palindromik
terakhir.
Contoh
Masukan: "anna"
Keluaran: anna
Masukan: "kyak"
Keluaran: kayak
function PalindromeSwapper(str) {
biarkan inputArray = str.split('');
biarkan strLen = inputArray.panjang;
biarkan palTester = function(arr) {
if (arr[i] !== arr[len - (1 + i)]) {
kembali salah;
}
}
kembali benar;
}
for (biarkan i = 0; i < strLen - 1; i++) {

biarkan newArray = Array.from(inputArray);
newArray.splice(i, 2, newArray[i + 1], newArray[i]);
if (palTester(newArray)) {
return newArray.join('');
}
}
kembali -1;
}

PalindromeSwapper(readline());
Hapus tanda kurung
Perintahkan fungsi RemoveBrackets( str ) ambil parameter string str yang akan diteruskan, yang
hanya akan berisi karakter "(" dan ")", dan tentukan jumlah minimum tanda kurung yang perlu dihapus
untuk membuat string tanda kurung yang cocok dengan benar. Sebagai contoh: jika str adalah "(()))"
maka program Anda harus mengembalikan angka 1 . Jawabannya berpotensi 0, dan akan selalu ada
setidaknya satu set tanda kurung yang cocok dalam string.
Contoh
Memasukkan: "(())()((("
Keluaran: 3
Memasukkan: "(()("
Keluaran: 2
fungsi RemoveBrackets(str) {
biarkan lemparan = 0;
biarkan arr = str.split('');

//contoh penggunaan pre++ dan pre-- sebagai kebalikan dari post++ dan post--
penghitung = arr[i] === '(' ? ++penghitung : --penghitung;
if (penghitung < 0) {
lemparan++;
penghitung = 0;
}
}
lemparan += penghitung;
lemparan kembali;
}
RemoveBrackets(readline());
Garis komando
Mintalah fungsi CommandLine( str ) mengambil parameter str yang diteruskan yang mewakili
parameter yang diberikan ke perintah dalam sistem PDP lama. Parameternya adalah token alfanumerik
(tanpa spasi) diikuti dengan tanda sama dengan dan nilai yang sesuai. Beberapa pasangan parameter/nilai
dapat ditempatkan pada baris perintah dengan spasi tunggal di antara setiap pasangan. Token dan nilai
parameter tidak boleh berisi tanda sama dengan tetapi nilai dapat berisi spasi. Tujuan dari fungsi ini
adalah untuk mengisolasi parameter dan nilai untuk mengembalikan daftar panjang parameter dan nilai.
Itu harus memberikan hasilnya dalam format yang sama dan dalam urutan yang sama dengan mengganti
setiap entri (token dan nilai) dengan panjang yang sesuai.
Misalnya, jika str adalah: "SampleNumber=3234 provider=Dr.M. Welby patient=John Smith

priority=High" maka fungsi Anda harus mengembalikan string "12=4 8=12 7=10 8=4" karena
"SampleNumber " adalah token 12 karakter dengan nilai 4 karakter ("3234") diikuti dengan "penyedia"
yang merupakan token 8 karakter diikuti dengan nilai 12 karakter ("Dr. M. Welby"), dll.
Contoh
Input: "huruf=angka ABZT=1 2 26 20 gabungkan=benar"

Keluaran: 7=7 7=9 7=4
Masukan: "a=3 b=4 a=23 b=a 4 23 c="

Keluaran: 1=1 1=1 1=2 1=6 1=0
function CommandLine(str) {
biarkan pembagi = /\s(?=\w+=)/
biarkan kataArr = str.split(splitter);
kataArr = kataArr.peta(pasangan => {

biarkan pairArr = pair.split('=');
pairArr = pairArr.peta(kata => {
kembali kata.panjang.toString();
});
return pairArr.join('=');
});
kembali kataArr.join(' ');

}

CommandLine(readline());
Peringkat Bintang
Miliki fungsi StarRating( str ) ambil parameter str yang akan diteruskan yang akan menjadi
peringkat rata-rata antara 0,00 dan 5,00, dan ubah peringkat ini menjadi daftar 5 nama gambar untuk
ditampilkan di antarmuka pengguna untuk mewakili peringkat sebagai daftar bintang dan setengah
bintang. Peringkat harus dibulatkan ke setengah terdekat. Ada 3 nama file gambar yang tersedia:
"full.jpg", "half.jpg", "empty.jpg". Outputnya adalah nama dari 5 gambar (tanpa ekstensi), dari kiri ke
kanan, dipisahkan oleh spasi. Sebagai contoh: jika str adalah "2.36" maka ini harus ditampilkan dengan
gambar berikut:
Jadi program Anda harus mengembalikan string "full full half empty empty".
Contoh
Masukan: "0,38"
Keluaran: setengah kosong kosong kosong kosong
Masukan: "4.5"
Keluaran: penuh penuh penuh setengah penuh
function Peringkat Bintang(str) {
biarkan num = (Math.round(parseFloat(str) * 2)) / 2;
biarkan starString = '';
biarkan setengah = !(Math.trunc(num) === num);
starString = starString + ' full'.repeat(num);

jika (setengah) {
starString += 'setengah';
}
kembali (starString + ' kosong'.ulangi(5 - num)).trim();
}

StarRating(readline());

Pemecahan Masalah-1

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Pemecahan Masalah-1

Diunggah oleh

Hak Cipta:

Format Tersedia

Terbalik Pertama

Masukan: "Saya Suka Kode"

var arr = str.split('');

// pertahankan panggilan fungsi ini di sini

biarkan newString = '';

kembalikan string baru;

// pertahankan panggilan fungsi ini di sini

// pertahankan panggilan fungsi ini di sini

for (biarkan i = 1; i <= num; i++) {

// pertahankan panggilan fungsi ini di sini

// pertahankan panggilan fungsi ini di sini

// pertahankan panggilan fungsi ini di sini

Masukan: "menyenangkan&!! waktu"

Masukan: "Saya suka anjing"

function Kata Terpanjang(sen) {

var arr = sen.split(' ');

arr.sort(function(a, b) {return b.length - a.length});

// pertahankan panggilan fungsi ini di sini

for (misalkan i = 0, panjang = 0, kata = ''; i < sen.panjang; i++) {

if (panjang > maxLength) {

kembali kata terpanjang;

// pertahankan panggilan fungsi ini di sini

function Kata Terpanjang(sen) {

// pertahankan panggilan fungsi ini di sini

function Perubahan Huruf(str) {

untuk (var i = 0; i < len; i++) {

// pertahankan panggilan fungsi ini di sini

function Perubahan Huruf(str) {

biarkan ValidCharacters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

biarkan newString = '';

biarkan vokal = 'aeiou';

biarkan finalString = '';

kembalikan string akhir;

// pertahankan panggilan fungsi ini di sini

function Perubahan Huruf(str) {

return str.replace(/[aeiou]/g, function(ch) {

// pertahankan panggilan fungsi ini di sini

// pertahankan panggilan fungsi ini di sini

// pertahankan panggilan fungsi ini di sini

// pertahankan panggilan fungsi ini di sini

Masukan: "halo dunia"

Masukan: "saya berlari ke sana"

kataarr = str.split(" ");

for (var i = 0, n = wordarr.length; i < n; i++) {

// pertahankan panggilan fungsi ini di sini

biarkan newString = '';

KataBaru = (str[i] === ' ') ? benar salah;

kembalikan string baru;

// pertahankan panggilan fungsi ini di sini

// pertahankan panggilan fungsi ini di sini

// pertahankan panggilan fungsi ini di sini

jika (str === '') {

biarkan hasil = str.split('').every(letterEval);

mengembalikan hasil? 'benar salah';

fungsi hurufEval(huruf, indeks) {

if (str[indeks - 1] === '+' && str[indeks + 1] === '+') {

// pertahankan panggilan fungsi ini di sini

// pertahankan panggilan fungsi ini di sini

Masukan: 3 & num2 = 122

Masukan: 67 & num2 = 67

jika (bil1 == bilangan2) {

// pertahankan panggilan fungsi ini di sini

// pertahankan panggilan fungsi ini di sini

// pertahankan panggilan fungsi ini di sini