# 5 Best Ways to Check if the First and Last Digit of the Smallest Number Forms a Prime in Python

Rate this post

π‘ Problem Formulation: You need to determine whether the smallest number in a given set has a first and last digit that, when combined together, form a prime number. If you’re given an array `[143, 235, 19]`, the smallest number is `19`, and the first and last digits `1` and `9` form the number `19`, which is prime. Hence, the desired output, in this case, is `True`.

## Method 1: Converting to String

This method involves converting the smallest number to a string, extracting the first and last characters, combining them to form a new number, and then checking if this new number is prime. The function `is_prime()` is used to verify the primeness of the formed number.

Here’s an example:

```def is_prime(num):
if num < 2:
return False
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
return False
return True

def first_last_prime(arr):
smallest_num = str(min(arr))
first_last = int(smallest_num[0] + smallest_num[-1])
return is_prime(first_last)

# Example Usage
print(first_last_prime([143, 235, 19]))```

Output:

`True`

This snippet defines a utility function `is_prime()` that efficiently checks for prime numbers and another function `first_last_prime()` which finds the smallest number in an array, concatenates its first and last digits, and determines if this new number is prime.

## Method 2: Without String Conversion

In this method, we employ mathematical operations to find the first and last digits of the smallest number without converting it to a string. This avoids overhead caused by type conversions and string manipulations.

Here’s an example:

```def is_prime(num):
if num < 2:
return False
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
return False
return True

def first_last_prime(arr):
smallest_num = min(arr)
last_digit = smallest_num % 10
while smallest_num >= 10:
smallest_num //= 10
first_digit = smallest_num
first_last = first_digit * 10 + last_digit
return is_prime(first_last)

# Example Usage
print(first_last_prime([143, 235, 19]))```

Output:

`True`

The function `first_last_prime()` calculates the first and last digits using division and modulus operators and then checks if the new number formed by these digits is prime.

## Method 3: Using List Comprehension and Lambdas

This method takes advantage of the concise syntax provided by list comprehension and lambda functions to achieve the same result in a more compact code.

Here’s an example:

```is_prime = lambda num: num > 1 and all(num % i for i in range(2, int(num ** 0.5) + 1))

def first_last_prime(arr):
smallest_str = str(min(arr))
return is_prime(int(smallest_str[0] + smallest_str[-1]))

# Example Usage
print(first_last_prime([143, 235, 19]))```

Output:

`True`

The lambda function `is_prime` succinctly checks for a prime number, and the smallest number’s first and last digits are concatenated and checked for primeness in the `first_last_prime()` function.

## Method 4: Using Regular Expressions

Regular expressions can be employed to directly extract the first and last digits from the smallest number converted to a string. This approach can make the code more readable for those familiar with regex patterns.

Here’s an example:

```import re

def is_prime(num):
if num < 2:
return False
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
return False
return True

def first_last_prime(arr):
smallest_str = str(min(arr))
first_last = int(re.search(r'^(.).*(.)\$', smallest_str).groups()[0] +
re.search(r'^(.).*(.)\$', smallest_str).groups()[1])
return is_prime(first_last)

# Example Usage
print(first_last_prime([143, 235, 19]))```

Output:

`True`

A regular expression pattern is used in the `first_last_prime()` function to capture the first and last digits and check the combined number for primeness via the `is_prime()` function.

## Bonus One-Liner Method 5: List Comprehension with Math and Lambda

Combining list comprehension with mathematical operations allows us to employ a one-liner Python expression that effectively solves the problem by finding the first and last digits and then checking their combination for primeness.

Here’s an example:

```print((lambda x: x > 1 and all(x % i for i in range(2, int(x ** 0.5) + 1)))
(int(str(min([143, 235, 19]))[0] + str(min([143, 235, 19]))[-1])))```

Output:

`True`

This Python one-liner combines list comprehension and lambda functions to find the first and last digits of the smallest number and checks if their combination is prime using an inline `is_prime()` check.

## Summary/Discussion

• Method 1: String Conversion. Easy to follow. Potentially less efficient due to string operations.
• Method 2: No String Conversion. More efficient for large numbers. Slightly more complex due to mathematical operations.
• Method 3: List Comprehension with Lambdas. Compact and elegant. May be less readable for those unfamiliar with lambdas.
• Method 4: Regular Expressions. Good readability for regex-savvy users. Slower due to regex overhead.
• Bonus Method 5: One-Liner. Very concise. Can be difficult to understand and debug.