Comment écrire palindrome en JavaScript
Je me demande comment écrire palindrome en javascript, où je saisis différents mots et programme indique si Word est ou non palindrome Par exemple, Word midi est palindrome, alors que mauvais ne l’est pas.
Merci d'avance.
function palindrome(str) {
var len = str.length;
var mid = Math.floor(len/2);
for ( var i = 0; i < mid; i++ ) {
if (str[i] !== str[len - 1 - i]) {
return false;
}
}
return true;
}
palindrome retournera si le mot spécifié est palindrome, basé sur la valeur boolean (true/false)
METTRE À JOUR:
J'ai ouvert la prime sur cette question en raison de la performance et j'ai fait des recherches et voici les résultats:
Si nous traitons avec une très grande quantité de données comme
var abc = "asdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfdasdhfkahkjdfhkaksjdfhaksdfjhakjddfhkjahksdhfaiuyqewiuryiquweyriyqiuweyriuqiuweryiquweyriuqyweirukajsdhfkahdfjkhakjsdhfkahksdhfakhdjkfqwiueryqiueyriuasdkfjhakjhdfkjashfkajhsdfkjahsdkalsdjflkasjdfljqoiweurasldjflasfd";
for ( var i = 0; i < 10; i++ ) {
abc += abc; // making string even more larger
}
function reverse(s) { // using this method for second half of string to be embedded
return s.split("").reverse().join("");
}
abc += reverse(abc); // adding second half string to make string true palindrome
Dans cet exemple, palindrome est True, il suffit de noter
La fonction palindrome publiée nous donne un temps allant de 180 à 210 millisecondes (dans l'exemple actuel), et la fonction publiée ci-dessous .__ avec la méthode string == string.split('').reverse().join('') nous donne de 980 à 1010 millisecondes.
Détails de la machine:
Système: Ubuntu 13.10 Type de système d'exploitation: 32 bits RAM: 2 Gb CPU: 3,4 Ghz * 2 Navigateur: Firefox 27.0.1
Essaye ça:
var isPalindrome = function (string) {
if (string == string.split('').reverse().join('')) {
alert(string + ' is palindrome.');
}
else {
alert(string + ' is not palindrome.');
}
}
document.getElementById('form_id').onsubmit = function() {
isPalindrome(document.getElementById('your_input').value);
}
Donc, ce script alerte le résultat, palindrome ou non. Vous devez modifier le your_id avec votre identifiant d'entrée et form_id avec votre identifiant de formulaire pour obtenir ce travail.
Utilisez quelque chose comme ça
function isPalindrome(s) {
return s == s.split("").reverse().join("") ? true : false;
}
alert(isPalindrome("noon"));
sinon, le code ci-dessus peut être optimisé comme [mis à jour après le commentaire de rightfold]
function isPalindrome(s) {
return s == s.split("").reverse().join("");
}
alert(isPalindrome("malayalam"));
alert(isPalindrome("english"));
Regarde ça:
function isPalindrome(Word){
if(Word==null || Word.length==0){
// up to you if you want true or false here, don't comment saying you
// would put true, I put this check here because of
// the following i < Math.ceil(Word.length/2) && i< Word.length
return false;
}
var lastIndex=Math.ceil(Word.length/2);
for (var i = 0; i < lastIndex && i< Word.length; i++) {
if (Word[i] != Word[word.length-1-i]) {
return false;
}
}
return true;
}
Éditer: maintenant, la moitié des opérations de comparaison sont effectuées, car je n’itère que moitié du mot Word pour le comparer à la dernière partie du mot. Plus rapide pour les grandes données !!!
Puisque la chaîne est un tableau de caractères, inutile d'utiliser les fonctions charAt !!!
Référence: http://wiki.answers.com/Q/Javascript_code_for_palindrome
Manière plus rapide:
-Calculer la moitié du chemin en boucle.
-Stock Longueur du mot dans une variable au lieu de calculer à chaque fois.
EDIT: Enregistrez la longueur du mot/2 dans une variable temporaire pour ne pas calculer chaque fois dans la boucle comme indiqué par (mvw).
function isPalindrome(Word){
var i,wLength = Word.length-1,wLengthToCompare = wLength/2;
for (i = 0; i <= wLengthToCompare ; i++) {
if (Word.charAt(i) != Word.charAt(wLength-i)) {
return false;
}
}
return true;
}
Commençons par la définition récursive d'un palindrome:
- La chaîne vide '' est un palindrome
- La chaîne composée du caractère c, donc 'c', est un palindrome
- Si la chaîne s est un palindrome, la chaîne 'c' + s + 'c' pour un caractère c est un palindrome
Cette définition peut être codée directement en JavaScript:
function isPalindrome(s) {
var len = s.length;
// definition clauses 1. and 2.
if (len < 2) {
return true;
}
// note: len >= 2
// definition clause 3.
if (s[0] != s[len - 1]) {
return false;
}
// note: string is of form s = 'a' + t + 'a'
// note: s.length >= 2 implies t.length >= 0
var t = s.substr(1, len - 2);
return isPalindrome(t);
}
Voici un code de test supplémentaire pour MongoDB's mongo JavaScript Shell, dans un navigateur Web avec le débogueur remplacer print () avec console.log ()
function test(s) {
print('isPalindrome(' + s + '): ' + isPalindrome(s));
}
test('');
test('a');
test('ab');
test('aa');
test('aab');
test('aba');
test('aaa');
test('abaa');
test('neilarmstronggnortsmralien');
test('neilarmstrongxgnortsmralien');
test('neilarmstrongxsortsmralien');
J'ai eu cette sortie:
$ mongo palindrome.js
MongoDB Shell version: 2.4.8
connecting to: test
isPalindrome(): true
isPalindrome(a): true
isPalindrome(ab): false
isPalindrome(aa): true
isPalindrome(aab): false
isPalindrome(aba): true
isPalindrome(aaa): true
isPalindrome(abaa): false
isPalindrome(neilarmstronggnortsmralien): true
isPalindrome(neilarmstrongxgnortsmralien): true
isPalindrome(neilarmstrongxsortsmralien): false
Une solution itérative est:
function isPalindrome(s) {
var len = s.length;
if (len < 2) {
return true;
}
var i = 0;
var j = len - 1;
while (i < j) {
if (s[i] != s[j]) {
return false;
}
i += 1;
j -= 1;
}
return true;
}
Prendre un coup de poignard à cela. Un peu difficile à mesurer, cependant.
function palin(Word) {
var i = 0,
len = Word.length - 1,
max = Word.length / 2 | 0;
while (i < max) {
if (Word.charCodeAt(i) !== Word.charCodeAt(len - i)) {
return false;
}
i += 1;
}
return true;
}
Ma pensée est d'utiliser charCodeAt() à la place de charAt() en espérant que l'attribution d'une Number au lieu d'une String aura de meilleurs résultats car Strings sont de longueur variable et pourraient être plus complexes à allouer. En outre, il ne fait que parcourir la moitié ( comme indiqué par sai ), car c’est tout ce qui est nécessaire. De plus, si la longueur est impaire (ex: 'aba'), le caractère du milieu est toujours correct.
La chose la plus importante à faire pour résoudre un test technique est N'utilisez pas de méthodes de raccourci - ils veulent voir comment vous pensez de manière algorithmique! Pas votre utilisation des méthodes.
En voici un que je suis venu avec (45 minutes après avoir fait le test). Il y a cependant quelques optimisations à faire. Lors de l'écriture d'un algorithme, il est préférable d'assumer false et de modifier la logique si sa recherche est true.
isPalindrome():
Fondamentalement, pour que cela fonctionne dans la complexité O(N) (linéaire), vous voulez avoir 2 itérateurs dont les vecteurs pointent l'un vers l'autre. Sens, un itérateur qui commence au début et un qui commence à la fin, chacun voyageant vers l'intérieur. Vous pouvez faire en sorte que les itérateurs parcourent tout le tableau et utilisent une condition pour breakreturn une fois qu'ils se rencontrent au milieu, mais cela peut économiser du travail de ne donner à chaque itérateur qu'un _/demi-longueur par défaut.
Les boucles for semblent forcer l’utilisation de davantage de vérifications; j’ai donc utilisé des boucles while - avec lesquelles je suis moins à l’aise.
Voici le code:
/**
* TODO: If func counts out, let it return 0
* * Assume !isPalindrome (invert logic)
*/
function isPalindrome(S){
var s = S
, len = s.length
, mid = len/2;
, i = 0, j = len-1;
while(i<mid){
var l = s.charAt(i);
while(j>=mid){
var r = s.charAt(j);
if(l === r){
console.log('@while *', i, l, '...', j, r);
--j;
break;
}
console.log('@while !', i, l, '...', j, r);
return 0;
}
++i;
}
return 1;
}
var nooe = solution('neveroddoreven'); // even char length
var kayak = solution('kayak'); // odd char length
var kayaks = solution('kayaks');
console.log('@isPalindrome', nooe, kayak, kayaks);
Notez que si les boucles sont comptées, elle retourne true. Toute la logique doit être inversée pour que, par défaut, elle renvoie false. J'ai également utilisé une méthode de raccourci String.prototype.charAt(n), mais je me sentais à l'aise avec cela car chaque langue supporte nativement cette méthode.
Le meilleur moyen de vérifier la chaîne est le palindrome avec davantage de critères tels que la casse et les caractères spéciaux.
function checkPalindrom(str) {
var str = str.replace(/[^a-zA-Z0-9]+/gi, '').toLowerCase();
return str == str.split('').reverse().join('');
}
Vous pouvez le tester avec les mots et les chaînes suivants et vous donne un résultat plus spécifique.
1. bob
2. Doc, remarque, je suis en désaccord. Un jeûne n'empêche jamais un gras. Je diète sur la morue
Pour les chaînes, il ignore les caractères spéciaux et convertit la chaîne en minuscule.
function palindrome(str) {
var re = /[^A-Za-z0-9]/g;
str = str.toLowerCase().replace(re, '');
var len = str.length;
for (var i = 0; i < len/2; i++) {
if (str[i] !== str[len - 1 - i]) {
return false;
}
}
return true;
}
Celui-ci, ça va?
function pall (Word) {
var lowerCWord = Word.toLowerCase();
var rev = lowerCWord.split('').reverse().join('');
return rev.startsWith(lowerCWord);
}
pall('Madam');
Cette fonction supprimera tous les caractères non alphanumériques (ponctuation, espaces et symboles) et transformera tout en minuscule afin de vérifier la présence de palindromes.
function palindrome(str){
var re = /[^A-Za-z0-9]/g;
str = str.toLowerCase().replace(re, '');
return str == str.split('').reverse().join('') ? true : false;
}
function palindrome(str) {
var lenMinusOne = str.length - 1;
var halfLen = Math.floor(str.length / 2);
for (var i = 0; i < halfLen; ++i) {
if (str[i] != str[lenMinusOne - i]) {
return false;
}
}
return true;
}
Optimisé pour l'analyse d'une demi-chaîne et pour les variables à valeur constante.
Voici un one-liner sans utiliser String.reverse,
const isPal = str => Array
.apply(null, new Array(strLen = str.length))
.reduce((acc, s, i) => acc + str[strLen - (i + 1)], '') === str;
25x plus rapide + récursif + non-branchement + terse
function isPalindrome(s,i) {
return (i=i||0)<0||i>=s.length>>1||s[i]==s[s.length-1-i]&&isPalindrome(s,++i);
}
str1 est la chaîne d'origine avec des caractères et des espaces non alphanumériques supprimés et str2 est la chaîne d'origine inversée.
function palindrome(str) {
var str1 = str.toLowerCase().replace(/\s/g, '').replace(
/[^a-zA-Z 0-9]/gi, "");
var str2 = str.toLowerCase().replace(/\s/g, '').replace(
/[^a-zA-Z 0-9]/gi, "").split("").reverse().join("");
if (str1 === str2) {
return true;
}
return false;
}
palindrome("almostomla");
Je pense que la fonction suivante avec une complexité temporelle de o (log n) sera meilleure.
function palindrom(s){
s = s.toString();
var f = true; l = s.length/2, len = s.length -1;
for(var i=0; i < l; i++){
if(s[i] != s[len - i]){
f = false;
break;
}
}
return f;
}
console.log (palindrom (12321));
Le code est concis, rapide, rapide et compréhensible.
TL; DR
Explication:
Ici, la fonction isPalindrome accepte un paramètre str qui est typeof string.
- Si la longueur du paramètre str est inférieure ou égale à un, elle renvoie simplement "false".
Si la casse ci-dessus est fausse, la seconde instruction if est vérifiée et vérifie si le caractère à la position 0 de la chaîne est identique au caractère à la dernière place. C'est un test d'inégalité entre les deux.
str.charAt(0) // gives us the value of character in string at position 0 str.slice(-1) // gives us the value of last character in the string.
Si le résultat de l'inégalité est vrai, il continue et renvoie faux.
- Si le résultat de la déclaration précédente est faux, il appelle de manière récursive la fonction
isPalindrome(str)encore et encore jusqu'au résultat final.
function isPalindrome(str){
if (str.length <= 1) return true;
if (str.charAt(0) != str.slice(-1)) return false;
return isPalindrome(str.substring(1,str.length-1));
};
document.getElementById('submit').addEventListener('click',function(){
var str = Prompt('whats the string?');
alert(isPalindrome(str))
});
document.getElementById('ispdrm').onsubmit = function(){alert(isPalindrome(document.getElementById('inputTxt').value));
}<!DOCTYPE html>
<html>
<body>
<form id='ispdrm'><input type="text" id="inputTxt"></form>
<button id="submit">Click me</button>
</body>
</html>function palindrome(s) {
var re = /[\W_]/g;
var lowRegStr = s.toLowerCase().replace(re, '');
var reverseStr = lowRegStr.split('').reverse().join('');
return reverseStr === lowRegStr;
}
Je ne sais pas comment JSPerf vérifie les performances du code. J'ai juste essayé d'inverser la chaîne et de vérifier les valeurs. Veuillez commenter les avantages et inconvénients de cette méthode.
function palindrome(str) {
var re = str.split(''),
reArr = re.slice(0).reverse();
for (a = 0; a < re.length; a++) {
if (re[a] == reArr[a]) {
return false;
} else {
return true;
}
}
}
Ou vous pouvez le faire comme ça.
var palindrome = Word => Word == Word.split('').reverse().join('')
Le code ci-dessous indique comment obtenir une chaîne à partir de textBox et vous indique si ce n'est pas un palindrome et affiche votre réponse dans un autre champ de texte
<html>
<head>
<meta charset="UTF-8"/>
<link rel="stylesheet" href=""/>
</head>
<body>
<h1>1234</h1>
<div id="demo">Example</div>
<a accessKey="x" href="http://www.google.com" id="com" >GooGle</a>
<h1 id="tar">"This is a Example Text..."</h1>
Number1 : <input type="text" name="txtname" id="numb"/>
Number2 : <input type="text" name="txtname2" id="numb2"/>
Number2 : <input type="text" name="txtname3" id="numb3" />
<button type="submit" id="sum" onclick="myfun()" >count</button>
<button type="button" id="so2" onclick="div()" >counnt</button><br/><br/>
<ol>
<li>water</li>
<li>Mazaa</li>
</ol><br/><br/>
<button onclick="myfun()">TryMe</button>
<script>
function myfun(){
var pass = document.getElementById("numb").value;
var rev = pass.split("").reverse().join("");
var text = document.getElementById("numb3");
text.value = rev;
if(pass === rev){
alert(pass + " is a Palindrome");
}else{
alert(pass + " is Not a Palindrome")
}
}
</script>
</body>
</html>
ES6 façon de le faire. Notez que je profite de la méthode array pour réduire les droits (reverseRight) pour inverser une chaîne (vous pouvez utiliser des méthodes array sur des chaînes si vous donnez la chaîne comme contexte, car les chaînes de bas niveau sont des tableaux de caractères). Non, il n’est pas aussi performant que d’autres solutions, mais je n’ai pas trouvé de réponse. Il a utilisé es6 ou des fonctions d’ordre supérieur, donc je me suis dit que jetterais celle-ci à l’extérieur.
const palindrome = str => {
const middle = str.length/2;
const left = str.slice(0, middle)
const right = Array.prototype.reduceRight.call(str.slice(Math.round(middle)), (str, char) => str + char, '')
return left === right;
}
function Palindrome(str) {
let forwardStr = str.toLowerCase().replace(/[\W_]/g, '');
let reversedStr = forwardStr.split('').reverse().join();
return forwardStr === reversedStr;
}
console.log(Palindrome('madam'));
Vous pouvez aussi faire quelque chose comme ça:
function isPalindrome(str) {
var newStr = '';
for(var i = str.length - 1; i >=0; i--) {
newStr += str[i];
}
if(newStr == str) {
return true;
return newStr;
} else {
return false;
return newStr;
}
}
Je pense que cette mise en œuvre couvre à peu près tous les cas. J'espère que c'est utile à quelqu'un:
function isPalindrome(Word){
if(typeof Word === 'undefined' || Word === null){
console.log("argument is undefined");
return;
}
if(typeof Word === 'string'){
Word = Word.replace(/\s/gi,"");
if(Word.length < 1){
console.log("wrong argument");
return;
}
if(Word.length === 1){
console.log("It's palindrome!");
return;
}
for(var i=0;i<Math.floor(Word.length/2);i++){
if(Word[i] !== Word[word.length - 1 - i]){
console.log("It's not palindrome");
return;
}
}
console.log("It's palindrome");
}else{
console.log("argument must be a string");
}
}
Et puis vous pouvez essayer avec ces cas:
isPalindrome("nurses run");
isPalindrome("abcdcba");
isPalindrome("hello world");
isPalindrome(" ");
isPalindrome(" ");
isPalindrome("");
isPalindrome(null);
isPalindrome();
isPalindrome(100);
isPalindrome({"name":"John"});
/ * La fonction suivante effectue la tâche mentionnée ci-dessous.
1. Fetch all the substrings of a given string.
2. Find which of the substrings are palindromes.
3. Find the longest palindrome.
4. Find if the longest palindrome is a lucky palindrome.
*/
function SubstringMnipulations(S) {
let Str = S.toString();
let AllSubStrs = splitSubstrings(Str);
let Pelindromes = arePelindrome(AllSubStrs);
let LongestPelindrome = getLongestString(Pelindromes);
let isPrimeVar = isPrime(LongestPelindrome);
return {
"possibleSubstrings": AllSubStrs,
"pelindromes": Pelindromes,
"longestPelindrome": LongestPelindrome,
"isLuckyPelindrome": isPrimeVar
};
}
function splitSubstrings(Str) {
let StrLength = Str.length;
let maxIndex = StrLength;
let AllSubStrs = [];
for(var index = 0; index < maxIndex; index++ ) {
for(var innerIndex = 1; innerIndex <= maxIndex-index; innerIndex++) {
AllSubStrs.Push(Str.substring(index, (index+innerIndex)));
}
}
return AllSubStrs;
}
function arePelindrome(StrArr) {
let pelindrome = [];
for(i=0; i<StrArr.length;i++) {
if(isPelindrome(StrArr[i])) {
if(StrArr[i].length>1) {
pelindrome.Push(StrArr[i]);
}
}
}
return pelindrome;
}
function isPelindrome(Str) {
let strLen = Str.length;
let firstHalfIndex = 0;
if(strLen==1) {
return true;
}
let firstHalf = "";
let secondHalf = "";
if(strLen>1 && strLen%2==0) {
firstHalfIndex = strLen/2;
firstHalf = Str.substring(0, firstHalfIndex);
secondHalf = Str.substring((firstHalfIndex), strLen);
} else {
firstHalfIndex = (strLen-1)/2;
firstHalf = Str.substring(0, firstHalfIndex);
secondHalf = Str.substring((1+firstHalfIndex), strLen);
}
secondHalf = reverseString(secondHalf);
return firstHalf === secondHalf;
}
function reverseString(Str) {
return Str.split("").reverse().join("");
}
function getLongestString(Str) {
let lengthCount = [];
for(i=0; i<Str.length;i++) {
lengthCount.Push(Str[i].length);
}
return Str[lengthCount.indexOf(Math.max(...lengthCount))];
}
function isPrime(Str) {
let input = Str.length;
let prime = true;
for (let i = 2; i <= Math.sqrt(input); i++) {
if (input % i == 0) {
prime = false;
break;
}
}
return prime && (input > 1);
}
function palindrome(str) {
var testString = str.toLowerCase();
var expression = /[a-z0-9\^s]/gi;
if (testString.match(expression).reverse().join("") == testString.match(expression).join("")) {
return true;
} else {
return false;
}
}
Toutes ces boucles! Que diriez-vous de la bonté fonctionnelle:) Peut se heurter à des problèmes d’appel en aval sur les moteurs js anciens/actuels, résolus dans ES6
function isPalendrome(str){
var valid = false;
if(str.length < 2 ) return true;
function even(i,ii){
str[i]===str[ii] ? ((i+1 !== ii) ? even(i+1,ii-1) : valid = true) : null
}
function odd(i, ii){
str[i]===str[ii] ? ((i !== ii) ? odd(i+1,ii-1) : valid = true) : null
}
if(str.length % 2){
return odd(0,str.length-1),valid;
}else{
return even(0,str.length-1),valid;
}
}
Pour tester votre pile d'appels, exécutez ce code, vous pourrez analyser les chaînes en doublant la taille de la pile d'appels.
function checkStackSize(){
var runs = 70000;
var max_process = 1;
var max = 0;
function recurse_me() {
max_process++;
if(max_process === runs) return;
max = max_process;
try {
recurse_me()
} catch(e) {
max = max_process;
}
}
recurse_me()
console.log(max);
}
En raison de la nature symétrique du problème, vous pouvez couper la chaîne de l'extérieur et traiter les morceaux se trouvant dans les limites de la pile d'appels.
je veux dire par là si la longueur des palindromes est de 1000. Vous pouvez joindre 0-250 et 750-1000 et rejoindre 250-499 avec 500-749. Vous pouvez ensuite transmettre chaque bloc à la fonction. L'avantage est que vous pouvez exécuter le processus en parallèle à l'aide de travailleurs Web ou de threads pour des ensembles de données très volumineux.
Ma solution courte, avec une longueur de 66 caractères. Le résultat: vrai ou faux.
function isPalindrome(s) {
s=s.toLowerCase().match(/\w/g);
return s.join()==s.reverse().join();
}Pour de meilleures performances, vous pouvez également utiliser celui-ci
function palindrome(str) {
str = str.split("");
var i = str.length;
var check = "Yes"
if (i > 1) {
for (var j = 0; j < i / 2; j++) {
if (str[j] != str[i - 1 - j]) {
check = "NO";
break;
}
}
console.log(check);
} else {
console.log("YES");
}
}
Pour éviter les erreurs avec des caractères spéciaux, utilisez cette fonction ci-dessous
function palindrome(str){
var removeChar = str.replace(/[^A-Z0-9]/ig, "").toLowerCase();
var checkPalindrome = removeChar.split('').reverse().join('');
if(removeChar === checkPalindrome){
return true;
}else{
return false;
}
}
Un simple code d'une ligne pour vérifier si la chaîne est palindrome ou non:
function palindrome (str) {
return str === str.split("").reverse().join("");
}<!-- Change the argument to check for other strings -->
<button type="button" onclick="alert(palindrome('naman'));">Click Me<utton>La fonction ci-dessus retournera true si la chaîne est palindrome. Sinon, ça va retourner faux.
function reversName(name){
return name
.split('')
.reverse()
.join('') === name ;
};
console.log(reversName('suus'));
console.log(reversName('suusss'));Voici une autre façon de le faire:
function isPalin(str) {
str = str.replace(/\W/g,'').toLowerCase();
return(str==str.split('').reverse().join(''));
}
Note: Ceci est sensible à la casse
function palindrome(Word)
{
for(var i=0;i<Word.length/2;i++)
if(Word.charAt(i)!=Word.charAt(Word.length-(i+1)))
return Word+" is Not a Palindrome";
return Word+" is Palindrome";
}
Voici le violon: http://jsfiddle.net/eJx4v/
function palindrome(str){
for (var i = 0; i <= str.length; i++){
if (str[i] !== str[str.length - 1 - i]) {
return "The string is not a palindrome";
}
}
return "The string IS a palindrome"
}
palindrome("abcdcba"); //"The string IS a palindrome"
palindrome("abcdcb"); //"The string is not a palindrome";
Si vous console.log cette ligne: console.log(str[i] + " and " + str[str.length - 1 - i]), avant l'instruction if, vous verrez ce que (str[str.length - 1 - i]) est. Je pense que c’est la partie la plus déroutante, mais vous l’obtiendrez facilement lorsque vous le vérifierez sur votre console.
Ceci teste chaque extrémité de la chaîne sortant de dehors en sortant dès qu'un manque de symétrie est détecté.
function isPalindrome(Word){
var head = 0;
var tail = Word.length - 1;
var palindrome = true;
while (palindrome && (head < tail)) {
if (Word.charAt(head) !== Word.charAt(tail)){
return false
} else {
head ++;
tail --;
}
};
return true;
};