在一个线程中求100以内的素数，求出一个素数后休眠一个随机时间。在另一个线程中求水仙花数，求出一个水仙花数后也休眠一个随机时间。输出数据时应有提示，指明是哪个线程输出的数据。

### 回答1：
以下是使用Python实现的代码：

import threading
import time
import random

# 判断是否为素数
def is_prime(n):
    if n <= 1:
        return False
    if n == 2:
        return True
    for i in range(2, int(n**0.5)+1):
        if n % i == 0:
            return False
    return True

# 获取100以内的所有素数
def get_primes():
    primes = []
    for i in range(2, 101):
        if is_prime(i):
            primes.append(i)
            print("线程1输出：素数 %d" % i)
            time.sleep(random.random())
    return primes

# 判断是否为水仙花数
def is_narcissistic_number(n):
    num_str = str(n)
    length = len(num_str)
    sum = 0
    for i in num_str:
        sum += int(i) ** length
    return sum == n

# 获取100以内的所有水仙花数
def get_narcissistic_numbers():
    narcissistic_numbers = []
    for i in range(100):
        if is_narcissistic_number(i):
            narcissistic_numbers.append(i)
            print("线程2输出：水仙花数 %d" % i)
            time.sleep(random.random())
    return narcissistic_numbers

if __name__ == '__main__':
    t1 = threading.Thread(target=get_primes)
    t2 = threading.Thread(target=get_narcissistic_numbers)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

程序中使用了两个函数分别获取100以内的素数和水仙花数，并在获取每一个素数和水仙花数后休眠一个随机时间。在主程序中创建了两个线程分别执行这两个函数，并在输出数据时加入了线程的提示。主程序中使用 `join()` 方法等待两个线程的结束。

### 回答2：
这个问题可以通过多线程编程来解决。我们可以创建两个线程，一个用于求100以内的素数，另一个用于求水仙花数。以下是一个简单的实现：

import threading
import random

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

def find_primes():
    for num in range(2, 101):
        if is_prime(num):
            print("素数线程输出的数据：", num)
            time.sleep(random.random())  # 随机休眠一段时间

def is_armstrong(num):
    temp = num
    sum = 0
    while temp > 0:
        digit = temp % 10
        sum += digit ** 3
        temp //= 10
    if num == sum:
        return True
    return False

def find_armstrong_numbers():
    for num in range(100):
        if is_armstrong(num):
            print("水仙花数线程输出的数据：", num)
            time.sleep(random.random())  # 随机休眠一段时间

if __name__ == "__main__":
    prime_thread = threading.Thread(target=find_primes)
    armstrong_thread = threading.Thread(target=find_armstrong_numbers)

    prime_thread.start()
    armstrong_thread.start()

    prime_thread.join()
    armstrong_thread.join()

在上述代码中，我们定义了一个is_prime()函数用于判断一个数字是否是素数，另一个is_armstrong()函数用于判断一个数字是否是水仙花数。然后，我们创建两个线程，一个用于调用find_primes()函数求素数，另一个用于调用find_armstrong_numbers()函数求水仙花数。在每次求出一个素数或水仙花数后，我们使用time.sleep()方法休眠一个随机时间。最后，通过调用start()方法启动线程，使用join()方法等待线程完成。

当运行代码时，我们会看到在输出数据时，会有相应的提示指明是哪个线程输出的数据，如"素数线程输出的数据："和"水仙花数线程输出的数据："。

### 回答3：
在实现上述要求的程序中，我们可以创建两个线程，一个用于求100以内的素数，另一个用于求水仙花数。下面是一个可能的实现：

import threading
import random

def is_prime(n):
    """判断一个数字是否是素数"""
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

def find_prime():
    """在一个线程中求100以内的素数，并输出数据"""
    while True:
        num = random.randint(2, 100)
        if is_prime(num):
            print("素数线程输出:", num)
        time.sleep(random.random())

def is_armstrong(n):
    """判断一个数字是否是水仙花数"""
    num_str = str(n)
    length = len(num_str)
    sum = 0
    for digit in num_str:
        sum += int(digit) ** length
    return sum == n

def find_armstrong():
    """在另一个线程中求水仙花数，并输出数据"""
    while True:
        num = random.randint(100, 999)
        if is_armstrong(num):
            print("水仙花数线程输出:", num)
        time.sleep(random.random())

# 创建并启动线程
t1 = threading.Thread(target=find_prime)
t2 = threading.Thread(target=find_armstrong)

t1.start()
t2.start()

在这个程序中，我们定义了`is_prime`函数来判断一个数字是否是素数，`is_armstrong`函数来判断一个数字是否是水仙花数。然后`find_prime`函数和`find_armstrong`函数分别在两个线程中使用`while True`循环生成一个随机数，然后判断该数是否是素数或水仙花数，并进行输出。

在输出时，我们使用`print`函数输出提示信息，并指明是哪个线程输出的数据。另外，我们使用了`time.sleep(random.random())`来使程序在输出数据后随机休眠一段时间。这样可以模拟出求解素数和水仙花数的进程间的并发性。