Ok. Then I'll have to add a clause. Or just declare it's not a palindrome, as there are no numbers ending up in a -. Or set it up differently, to compare places 1 ( bypassing the 1st/0th spot) through k with places k through 1.PeterDonis said:Yes, but what about strings that represent negative numbers?
This sort of check was already in the code in item 1 in your OP. That's why I was somewhat confused that you left this out in the new code.WWGD said:Ok. Then I'll have to add a clause.
int isPalindrome(char *inp)
{ return (strcmp(inp, strrev(inp))==0) }
Sure, if you leave out the requirement to evaluate strings representing negative numbers without including the minus sign. And if you leave out printed output of the results. But the OP is including both of those things. Without them, of course you could do it as a one-liner in Python as easily as you can in C.Svein said:Sigh. In C:
int isPalindrome(char *inp) { return (strcmp(inp, strrev(inp))==0) }
# Reversing a string :
def Rev(x):
String = str(x)
if String[0]= '- ' :
return int( '-' + String[ :0:-1} )
else:
return int( String[:: -1] )String = str(x) and you would return a string, not an integer). It is designed to reverse the (decimal) digits of an INTEGER. But it has a few typos, and there is a better way to implement it. First let's sort the typos:# Reverse an integer.
def Rev(x):
String = str(x)
if String[0] == '-':
return int('-' + String[:0:-1])
else:
return int(String[::-1])assert Rev(123) == 321
assert Rev(-123) == -321
assert Rev(120) == 21
assert Rev(-120) == -21
print("Passed")def getReversedDigits(n: int) -> int:
'''Takes an integer n, returns n with its digits reversed.'''
if x < 0:
return -int(str(-x)[::-1])
return int(str(x)[::-1])def isIntegerPalindrome(n: int) -> bool:
'''Takes an integer n, returns True iff n is a palindrome, otherwise False.'''
return n == getReversedDigits(n)isIntegerPalindrome. -> false is how Erlang returns values. Erlang uses pattern matching to determine which branch of an if clause or a case clause. If the string is not null, there isn't a match with string:is_empty(Str), but there will othewise be a match with true.-module(pal).
-export([palindrome/1]).
palindrome(Str) ->
Len = string:length(Str),
case string:is_empty(Str) of
true -> false; %% Null string
false -> %% String contains at least one character
Start = string:slice(Str, 0, 1),
End = string:slice(Str, Len-1, 1),
case Len of
1 -> true; %% One char string
2 -> %% Two chars string
if
Start =/= End -> false;
Start == End -> true
end;
_ -> %% Three or more chars
if
Start =/= End -> false;
Start == End ->
NewStr = string:slice(Str, 1, Len-2),
palindrome(NewStr)
end
end
end.That's right -- case 3 isn't needed. I whipped the code up today, and didn't think it all the way through. If a string has an odd number of characters, and it successfully passes the tests for first and last characters being equal, the last recursive call will have a string with 1 character, which is handled by case 1, In the same fashion, a string with an even number of characters that successfully passes the same tests, will eventually get down to a string with two characters, which is handled by case 2.Tom.G said:.. it looks like case 3 is not needed.
The "%% Four or more chars" can easily handle it.
Erlang permits only single assignment to a variable, so yes, a new string is created in each recursive call. However, the code I wrote uses a tail call, and the Erlang compiler is able to optimize recursive calls of this sort.pbuk said:Unless the Erlang compiler has an optimization setting of "prescient" that algorithm is going to result in really expensive code - it has to create ## n \over 2 ## new strings using ## \mathcal O(n^2) ## memory! There is a way to efficiently test for palindromes with a recursive algorithm, provided you have a compiler with tail call optimization.
I'm not sure that would make a difference. I don't know enough about Erlang to know whether it passes parameters by reference or by value, or if in each call to palindrome() a copy of the string (possibly shortened as you described) is made.pbuk said:If you add an offset parameter to the function call you can keep calling if with the same string.
-module(pal).
-export([palindrome/1]).
palindrome([]) -> false; %% Null string
palindrome(Str) -> %% Non-null string
Len = string:length(Str),
Start = string:slice(Str, 0, 1),
End = string:slice(Str, Len-1, 1),
case Len of
1 -> true; %% One char string
2 -> %% Two chars string
if
Start =/= End -> false;
Start == End -> true
end;
_ -> %% Three or more chars
if
Start =/= End -> false;
Start == End ->
NewStr = string:slice(Str, 1, Len-2),
palindrome(NewStr) %% Recursive call
end
end.Oh it would:Mark44 said:I'm not sure that would make a difference.
doEndsMatch(Candidate, Offset0, Offset1) ->
Left = string:slice(Candidate, Offset0, 1),
Right = string:slice(Candidate, Offset1, 1),
if
Left =/= Right -> false;
Offset1 - Offset0 < 3 -> true;
true ->
doEndsMatch(Candidate, Offset0 + 1, Offset1 - 1)
end.
isPalindrome([]) -> false;
isPalindrome(Candidate) ->
doEndsMatch(Candidate, 0, string:length(Candidate) - 1).All variables in Erlang are immutable so the distinction is not relevant.Mark44 said:I don't know enough about Erlang to know whether it passes parameters by reference or by value
You are making the (shortened) copy explicitly yourself withMark44 said:or if in each call to palindrome() a copy of the string (possibly shortened as you described) is made.
NewStr = string:slice(Str, 1, Len-2).No, I use Replit for quick coding in languages I rarely use: https://replit.com/@pbuk/OfficialHeartfeltLibraryMark44 said:@pbuk, nice!
Do you have Erlang installed?
Then you would need to define how whitespace (and other non-alphanumeric) characters should be treated in the context of a palindrome (I would do this by adding test cases), work out whether the way the current algorithm deals with them fits that definition (by running the test cases), and if not, change it so that it does (and all the tests pass).Svein said:OK. What if the string starts with some whitespace?
I'm still figuring out how to compose slices [:a:b} , with a,b Integers, to eliminate a last place 0 and then reverse it. I've been putting of the (pretentious term) , algebra of slices (to avoid going ito loc. and .iloc). So far, I get that [:0:-1] reverses. But I need to set up an hour or so to detail it.pbuk said:And if you are going to handle numbers, be careful with e.g. 12343210. This is why we have unit testing (another reason why playing with the REPL or Jupyter notebook is not "real" programming).
This is more at an intro level, so not really an issue and would require too much of a detour.Svein said:OK. What if the string starts with some whitespace?
I know this is old, and maybe it's covered elsewhere in this thread. In Jupyter, if you run a cell that creates a function or variable, then those functions and variables will remain in memory, available to use for the remainder of that session (until you close or reset the Kernel). You could open a notebook, then scroll halfway down, execute a cell which creates some variables or functions, then scroll back to the top and use those functions.WWGD said:A general question about Jupyter for Python : Do definitions apply throughout in different cells in the same notebook, i.e., if I define a function in cell j of notebook k, can I apply it in any other cell of the same notebook k? Strangely, I've been able to do it only some times. I m ean, I used Rev(x), the function that reverses a string, in the definition of the Pal function, as in : "if String==Rev(String) return("Yes, Pal"), but this hasn't worked other times.
Heading out till tomorrow on PC. Thanks all.