Палиндром

var poly = 1221;
var ylop = 0;
var isPalindrome = false;

var polyCheck = poly;

for (var i = 0; i <= String(poly).length; i++) {
  ylop += (poly % 10) * Math.pow(10,(String(poly).length - 1)); 
  poly = (poly - (poly % 10)) / 10;
}

ylop += poly;

if (ylop == polyCheck) {
 isPalindrome = true;
}
ylop = poly.toString();
var symbAmount=ylop.length;

var n=~~(symbAmount/2); /*Пробовал 
math.round, но она округляет в 
большую сторону*/
var b=-1;
for (var i=0; i<n; i++) {
  if (i==0) {
   if ( ylop.slice(i,(i+1)) == ylop.slice(b)) {
    isPalindrome = true;
   }else{isPalindrome=false; 
     break;/*сравнение первого и 
  последнего символов*/
   }
 }
  else if (ylop.slice(i,(i+1))==ylop.slice((b-1),b)) {
    b=b-1;
    isPalindrome=true;
  }else{isPalindrome=false;
   break; /*сравнение второго и 
предпоследнего, и т.д.*/
 }
} /*проверка останавливается, как 
только натыкается на первое 
несовпадение*/
1 лайк

Усовершенствованный вариант:

ylop = poly.toString();
var n = (ylop.length - 1);
for (var i=0; i<(Math.floor(ylop.length/2));i++) {
  if (ylop[i] == ylop[n]) {
    console.log(ylop[i],ylop[n]);
    isPalindrome = true;
    n -= 1;
    }else{
     isPalindrome = false;
     break;
    }
 }
 console.log(isPalindrome);
var poly = 1221;
var polyHelp = poly; //чтобы не затерлось первое значение
var ylop = 0;
var isPalindrome = false;

if (poly >= 10) {    //это проверка на одноразрядное число
  ylop = polyHelp % 10;
  while (polyHelp > 9) {
    polyHelp = ~~(polyHelp / 10);
    ylop = ylop * 10 + polyHelp % 10;
  }
} else {
  ylop = poly;
}
if (ylop === poly) {
  isPalindrome = true;
}

это мой вариант без использования строк.

Соорудила вот такой вариант.

var poly = 1221;
var ylop = 0;
var isPalindrome = false;

var number;
var polyForCount = poly;

while (polyForCount > 0) {
number = polyForCount % 10;
polyForCount = ((polyForCount - number)/10);
ylop = (ylop*10) + number;
}

if (poly === ylop) {
isPalindrome = true;
} else { isPalindrome;
}

1 лайк

Не понял встроенной подсказки. Хотя и посмотрел ее после того как сам решил. Но решение как по мне не лаконичное. Тут в примерах намного короче увидел. Мне пришлось вообще вносить длинную формулу. Ну и конечно использовал предыдущие упражнения (как подсчет цыфр в числе). Ну и конечно применял только изученное.

var poly = 1221;
var ylop = 0;
var isPalindrome = false;

//Ищем кол-во знаков в числе

var number = poly;
var quantity = 0;
while (number > 1) {
  number /=10;
  quantity++;
}
//Переворачиваем число

var razryad = 10;
var mnoz = 1;
var mnoz2 = 1;

for (j = 1; j < quantity; j++) {mnoz2 *= 10}

for (var i = 1; i <= quantity; i++) {
  ylop += (poly % (razryad * mnoz) - (poly % mnoz)) / mnoz * mnoz2;
  mnoz *= 10;
  mnoz2 /=10;
}
//Сравниваем с изначальным

if (poly == ylop) {isPalindrome = true} else {isPalindrome = false}
1 лайк

Хорошее и очень короткое решение. Но Math.trunc к этому моменту еще не проходили. ))

var poly = 3223;
var ylop = 0;
var isPalindrome = false;
var fakePoly = poly;

var beforeComma = 0;
var divider = 10;

while (fakePoly > 0.1) {
  
  beforeComma = fakePoly % divider;
  fakePoly = (fakePoly / divider) - (fakePoly % divider) / divider;
  ylop += beforeComma.toString()
 }

ylop = parseInt(ylop, 10);

if (ylop == poly) {
  isPalindrome = true;
} else {
  isPalindrome = false;
}

До простого и лаконичного решения пока не дошел, буду пробовать ещё. А пока вот:

var poly = 123456789;
var ylop = 0;
var isPalindrome = false;
var fakePoly = poly;
var quantity = 0;           // количество знаков.

while (fakePoly >= 1) {
  fakePoly /= 10;
  quantity++; 
  }

console.log(quantity + ' quantity')

fakePoly = poly;

var number;
while (fakePoly > 0) {
   number = fakePoly % 10;
 
 for (var i = 1; i <= quantity - 1; i++) { 
 number *= 10;
 }
 
 quantity--;
 console.log(number + ' number')
 fakePoly = fakePoly / 10 - (fakePoly % 10) / 10;

 ylop += number;
 console.log(ylop + ' ylop');
}

if (ylop === poly) {
  isPalindrome = true;
}

Решил с помощью встроенной подсказки.:see_no_evil:

var poly = 126780001;
var ylop = 0;
var isPalindrome = false;
var fakePoly = poly;


while (fakePoly >= 1) {
  ylop = fakePoly % 10 + ylop * 10;
  fakePoly = fakePoly / 10 - (fakePoly % 10) / 10;
}

if (ylop === poly) {
  isPalindrome = true;
}
1 лайк

Исходя из того, что тема все таки была о циклах, Ваш @deevtmb вариант решения выглядит самым оптимальным. Но, @GreenLera, проверка на числе 1234567890987654321 все таки не работает:

И вот что получается, если вывести в консоль переменную ylop, то число у нас получается совсем не 1234567890987654321, а 44567890987654320 :

Скриншотик

Хм… как же так? Проверки на других числах ведь работают :thinking:

Как оказывается, в javascript есть такое понятие как БЕЗОПАСНЫЕ ЧИСЛА:

Безопасные целые числа состоят из всех целых чисел в диапазоне
от -(2^53 - 1) до 2^53- 1 включительно.

Все что не попало в этот диапазон (и наш палиндром в том числе :point_up: ) округляется в режимах округления к ближайшему и к нулю так, чтоб число все таки вписалалось в диапазон безопасных чисел.

И вот, что мы имеем: мы то думаем, что работаем с числом 1234567890987654321, а на самом деле в цикл у нас попадает уже число 1234567890987654400, т.к. наш палиндром в диапазон безопасных чисел не вписался и javascript заботливо выполнил все округления, чтоб число в диапазон все таки попало:

Ещё один скриншотик

Как-то так :nerd_face:

поверьте, Лера в курсе =)
а это вычисление и не должно работать собственно. для таких длинных чисел есть метод поиска подстроки с начала и конца на проверку палиндрома.
вот вам еще “парадокс”: 0.1 + 0.2 === 0.3 ==> false
по той же причине. особо глубоко не копайте, жабаскрипт не предназначен для космически точных вычислений. не точнее калькулятора бытового.

вот вам еще одна насущная проблема в программировании, с тем же связана. и да, она также затрагивает жс, т.к. жс вырос из языка С

Верю:slight_smile:

Но я что шарилась в гугле и расписывала итерации цикла, чтобы все таки докопаться до того, почему же с одними числами - ок, а с другими - не ок, и оставить эту инфу себе?)

Может кому-то она пригодится)

1 лайк

а тут больше дело в том, что чем глубже проникаешь в жс, тем глубже понимаешь в какую жо…жожореференс влезаешь =) даже те же сравнения чего стоят. почитайте на досуге по каким именно правилам работает сравнение при приведении типов, а также решите простой вопрос, почему
null > 0; // false
null == 0; // false
null >= 0; // true

Решение основано на подсказке в ТЗ
var poly = 5005;
var ylop = 0;
var isPalindrome = false;

while (poly >= 1){
ylop = ylop * 10 + poly % 10;
poly = Math.floor(poly / 10);

if (poly === ylop){
isPalindrome = true;
}
};

Если бы я не верил что можно решить с помощью пройденного материала !!!

var poly = 5665;
var ylop = 0;
var isPalindrome = false;
var workpoly=poly;

while (workpoly>0)
{
ylop=ylop + workpoly%10;
console.log(ylop);

ylop =ylop *10;
console.log(ylop);

workpoly=workpoly - workpoly%10;
console.log(workpoly);

workpoly=workpoly /10;
console.log(workpoly);
}
ylop=ylop/10;
console.log(ylop);

if (poly === ylop) {
isPalindrome = true;
}

На том уровне знаний, при котором эта задача объявляется - то есть циклы > практика, я использовал обретенное в категории циклы > теория. А это:
использование самого цикла, нахождение количества цифр в чилсе, возведение из типа данных number в string и обратно, подсказку к заданию и самое главное, использовал логику.
Возможно, код у меня получился чуть больше, но он железный. Проверял на любых числах, выдает верные результаты.
И все же лучше подсказки, чем готовые решения, иначе от учёбы мало толку.
Ниже код:

var poly = 9;
var quantity = 0;
var number = poly;
var oper = poly
var ylop = 0;
var ylop2 = 0;
var ylopVar = 0;
var ylopVar2 = '';
var isPalindrome = false;



if ( number >= 0 && number < 10 ){
  quantity = 1;
  } else{ for (var i = 1; number >= 10; i++){
    number /= 10 ;
    quantity = i; 
    }
    quantity = i;}


if (quantity >1){
  for(var i = 1; poly >i; i*=10 ){
  ylopVar = oper % 10;
  ylop2 = ylopVar .toString();
  ylopVar2+=ylop2
  oper = (oper - ylopVar) / 10;
  }
  ylop = ylopVar2;
  ylop = parseInt(ylop,10)
  }else{ 
    ylop= oper % 10;
    }
    
    
    if (ylop !== poly || quantity < 2){
    isPalindrome = false
    }else{
      isPalindrome = true
        }

по сложному пути пошли. вам не нужно искать разрядность числа.
вам нужна просто 1 временная переменная и нестрогое сравнение, чтобы сравнить 2 числа).

var poly = 50205;
var ylop = ""; // изменим тут, ниже поймете зачем
var isPalindrome = false;
var temp = poly;
for (var i = 0; temp > 0; i++) { // i тут тупо счетчик, условие выхода, что число больше не сосчитать по разрядам (т.е. по итерациям цикла)
  ylop += (temp % 10); // число + любая строка = строка
  temp = parseInt(temp/10, 10); // parseInt тащем-та работает не просто как преобразователь к числу. если это число дробное, оно его еще и обрезает до целого вниз. Math.floor (округление) вы изучите в следующей главе.
  console.log(`${i} итерация: temp = ${temp}, ylop = ${ylop} (${typeof(ylop)})`); // вы шаблоны не пройдете в курсах от академии, добавил, чтобы вам наглядно было что происходит на каждой итерации цикла, а заодно видели тип данных, не обязательная строка в общем-то
} 
if (poly == ylop) { isPalindrome = true; } // почему не строгое? ну влом приводить к числу, нам же не важен тип данных =) 

Помните, что прибавляя даже пустую строку вы меняете тип данных на строковый. а это как раз и надо, чтобы дописывать в конец строки остаток от деления на 10.
И заметьте, нет ничего такого, что вы не изучали.

вообще без доп. переменных
var poly = 50205;
var ylop = "";
var isPalindrome = false;

for (var i = poly; i > 0; i = parseInt(i/10, 10)) { 
  ylop += (i % 10); 
  console.log(`i = ${i}, ylop = ${ylop} (${typeof(ylop)})`);
} 
if (poly == ylop) { isPalindrome = true; }
1 лайк

var poly = 121;
var ylop = 0;
var isPalindrome = false;
var number = poly;

while (number > 0) {
ylop = ylop * 10 + (number % 10);
number = (number - (number % 10)) / 10;
}

if (ylop === poly) {
isPalindrome = true;
}

нечего сказать, круто)
Благодарю!
Мои решения пока прямолинейные, потому как начинающий, пока осваиваю основы, твой способ намного упрощённый в плане кода (нет лишних переменных, а сама суть поместилась в 2-х строчках). Я запомнил свои ошибки.