90% of /g/ will get this wrong

>>105718989 (OP)
You don't need to reverse a word to check if it's a palindrome what is this brainlet nonsense

>>105718989 (OP)
>Wordswordswords

B. What do I win.
>inb4 tranny porn

>>105719014
If you don't reverse it how do you know it's a palindrome?

>>105718989 (OP)
Pro tip: Always use the option with less nesting.

>>105719056
by asking kindly

>>105719056
i=0
k=s.length
While(i<k)
if(s[i]!=s[k])
return false
i++
k--
return true

>>105718989 (OP)
All 3 solutions are dogshit
You are not hired, you're brown.

>>105719071
>blocks your path

>>105719134
I don't think your implicit claim, that only people who come up with the most optimized solution to a problem are the ones who get hired, is true
if that was the case software would be way less shitty than it is now

>>105718989 (OP)
because empty array is undefined?

i can't remember the exact method, but isn't there a way to use modulus to quickly check for a palindrome? it has to do with isolating each character position and then checking for symmetry directly.

>>105719143
>dart
God no... Please no !!!

>>105719146
This anon gets it. Fire everyone, and let the AI take over.

>>105719146
I know as hell I wouldn't let me boss hire you.
You see, a lead dev is always present when hiring someone new to our team, in this case it would be me and sure as hell, I wouldn't accept any of OP's shitty solutions.

I would however accept his (but whit one less variable):>>105719123

>>105718989 (OP)
This is part of a recruitment process for a literal pyramid scheme. OP is a retard bragging about being scammed.

>>105719192
Ah yes, you could do
i=0
While(i<s.length-i)
if(s[i]!=s[s.length-i])
return false
i++
return true
Is that actually better tho? You have to dereference s.length every iteration. I suppose it gets cached tho

>>105719192
i = 0;
while (i <= trunc(s.len))
if (s[i] != s[s.len - i - 1])
return false;
i++;
return true;

>interview questions for ants

The craziest thing is you can earn way more money in other white collar jobs and the interviews are never this retarded

The whole our company is the most elite dance for us monkey shit gets old real quick after you do enough of them

What you eventually get is that everyone is trying to hide the fact that the job is fuck easy and there’s so many people banging on every door that it’s completely a mistake

That a ton of these people have nothing else they’re good at in life or going on that they enshrine CRUDing as some awesome thing
That other code “smells” or some shit

It’s dickwaving by small people who would get crushed in any real situation
A fucking corner boy fent dealer could steamroll everyone in the room in real life

It’s a job for losers and pussies

>>105719134
AI doubters are getting so btfo these days it's actually incredible. That is nuts.

>>105718989 (OP)
leave it to /g/ neet retards to completely miss the point of this question and jerk themselves off over their "optimized" solutions instead. you would all fail this question miserably.

>>105719252
fix:
while (2*i < s.len)

but 'racecar' should be True

>>105718989 (OP)
In Python this is just
def Check_Palindromes(word_list):
return all(word == word[::-1] for word in word_list)

>>105718989 (OP)
Can confirm
>t. Got it wrong 9 times out of 10

>>105719134

>>105719310
AI is getting weird

>>105719265
I mean, most well-equipped high-level languages will have a reverse() method and an all(condition) method. The task is trivial.
Low-level languages will require manual implementation just like what the neets here are doing.

>>105718989 (OP)
Option C is the longest, so it's obviously the most correct.

>>105719242
>it gets cached ?
Yes, either runtime optimizer (in case of jit) or the compiler will sort that out.

>>105719242
>You have to dereference s.length every iteration
If you're that concerned about it, you could store it in a stack variable.

>>105719325
The point is that you should be able to recognize that only one of them works with any number of words while the other two only work for exactly three.

>>105719422
Since when "best practices" means "find the one option that actually functions"? Besides, the only correct one has a bad of cleancodeitis.

>>105719457
*case

>>105719324
always has been
>deep dream

>>105719457
>Since when "best practices" means "find the one option that actually functions"?
It's a best practice to write code that works.

>>105718989 (OP)
Solution 4: don't ask AI and code it yourself.

>>105719259
Soon, the entire movie industry will shift to Ai aided content

>>105719534
That would probably improve the quality over what it shits out now.

>>105719296
You've failed the interview due to being illiterate. Congratz.

>>105719569
OP was right, 90% is wrong.

>>105719242
It depends on what exactly your code looks like. If you're using strlen() on C-style char* strings it actually might fail to cache but not in this example since you're just doing pure stuff locally. In any case, caching strlen() into a temp variable is free since it's more or less the same as you directly telling the compiler to cache it.

>>105718989 (OP)
>reversing a string to check for palindromes
An Indian (AI) wrote this.

Option B seems perfectly fine to me. Yeah, checking the existing string for palindromitude in-place character by character is faster, but this version is more obvious, which is usually more important if not specified otherwise.

>>105718989 (OP)
>Pseudocode
There is no correct answer. You can't evaluate the efficacy of something that doesn't function.

B is clearly the best answer of the 3, the others are pajeet i fear for loops level of shit

Not that the best of the three is the most optimal

>>105718989 (OP)
Get what wrong? There is no question, just an observation of how "AI" handles a programming request

>>105718989 (OP)
>hur dur let's put the helper functions at the top
no fuck you every ide worth their salt can quickly jump between call site and declaration. all of these solutions belong in the trash

>>105722149
have you ever been to a school?

>>105719014
This is the only valid answer.

def are_all_palindromic(arr):
def reverse_str(s):
if s == "":
return ""
else:
return reverse_str(s[1:]) + s[0]

def is_palindrome(el):
s = str(el) # Convert to string
n = len(s) # Number of characters

# Check for edge cases
if n == 0:
return True # Empty string
elif n == 1:
return True # Single character
else:
# Check for base case
first_last_match = (s[0] == s[-1])
inner_check = is_palindrome(s[1:-1]) if n > 2 else True
reversed_full = reverse_str(s)
full_match = (s == reversed_full)

midpoint = n // 2
first_half = s[:midpoint]
second_half = s[n - midpoint:]
reversed_second = reverse_str(second_half)
half_match = (first_half == reversed_second)

# Return final result
return first_last_match and inner_check and full_match and half_match

i = 0
# Check if all elements are palindromic
result = True
# Copy array
arr_copy = arr[:]

# Iterate through array
while i < len(arr_copy):
current = arr_copy[i]

check1 = is_palindrome(current)
check2 = (str(current) == str(current)[::-1])

if check1 == check2:
result = result and check1
else:
s = str(current)
mid = len(s) // 2
valid = True
for j in range(mid + 1):
# Check if first half is equal to second half
if j < len(s) and (len(s) - 1 - j) >= 0:
# Check if characters are equal
if s[j] != s[len(s) - 1 - j]:
# Set valid to false
valid = False
result = result and valid

i += 1

return result

>>105718989 (OP)
Ok. What's the question?

>>105718989 (OP)
all fail. the instruction was to return True or False, not true or false

>>105718989 (OP)
sigh.

>>105719071
This is the best and concise answer. Nesting is a nightmare to deal with.