基本情報技術者試験のPythonコード

```
def linear_search(arr, target):
    """線形探索: 配列を最初から順にチェック"""
    for i in range(len(arr)):
        if arr[i] == target:
            return i  # 要素が見つかった場合、そのインデックスを返す
    return -1  # 要素が見つからなかった場合、-1を返す

def binary_search(arr, target):
    """2部探索: ソートされた配列に対して二分探索を実行"""
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid  # 要素が見つかった場合、そのインデックスを返す
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1  # 要素が見つからなかった場合、-1を返す

def hash_search(hash_table, target):
    """ハッシュ探索: ハッシュテーブル内での検索"""
    if target in hash_table:
        return hash_table[target]  # 要素が見つかった場合、その値を返す
    return -1  # 要素が見つからなかった場合、-1を返す

# 使用例

# 線形探索
arr = [1, 3, 5, 7, 9]
target = 7
index_linear = linear_search(arr, target)
print(f'線形探索: 要素 {target} のインデックス: {index_linear}')

# 2部探索
arr_sorted = [1, 3, 5, 7, 9]  # 2部探索はソートされた配列に対して使用
target = 7
index_binary = binary_search(arr_sorted, target)
print(f'2部探索: 要素 {target} のインデックス: {index_binary}')

# ハッシュ探索
hash_table = {1: 'a', 3: 'b', 5: 'c', 7: 'd', 9: 'e'}
target = 7
value_hash = hash_search(hash_table, target)
print(f'ハッシュ探索: 要素 {target} の値: {value_hash}')

```

```

def bit_shift_examples(value):
    # 左シフト（2ビット分）
    left_shift = value << 2
    # 右シフト（2ビット分）
    right_shift = value >> 2
    
    return left_shift, right_shift

# 使用例
value = 8  # 0b1000
left_shift, right_shift = bit_shift_examples(value)
print(f'元の値: {value}')
print(f'左シフト（2ビット）: {left_shift} (0b{left_shift:b})')
print(f'右シフト（2ビット）: {right_shift} (0b{right_shift:b})')

```


```
def floating_point_operations(a, b):
    # 基本的な演算
    addition = a + b
    subtraction = a - b
    multiplication = a * b
    division = a / b
    
    return addition, subtraction, multiplication, division

def floating_point_precision(value):
    import sys
    # 浮動小数点数の精度
    precision = sys.float_info.dig
    # 浮動小数点数の表現形式
    format_value = format(value, '.15f')
    
    return precision, format_value

# 使用例
a = 1.234567890123456
b = 2.345678901234567

# 浮動小数点演算
addition, subtraction, multiplication, division = floating_point_operations(a, b)
print(f'足し算: {addition}')
print(f'引き算: {subtraction}')
print(f'掛け算: {multiplication}')
print(f'割り算: {division}')

# 浮動小数点数の精度と表現形式
precision, format_value = floating_point_precision(a)
print(f'浮動小数点数の精度: {precision} 桁')
print(f'浮動小数点数の表現: {format_value}')


```


```
class DFA:
    def __init__(self):
        # 状態を定義
        self.states = {'q0', 'q1', 'q2'}
        # 初期状態
        self.start_state = 'q0'
        # 受理状態
        self.accept_states = {'q2'}
        # 状態遷移関数: (状態, 入力) -> 次の状態
        self.transition_function = {
            ('q0', 'a'): 'q1',
            ('q0', 'b'): 'q0',
            ('q1', 'a'): 'q1',
            ('q1', 'b'): 'q2',
            ('q2', 'a'): 'q1',
            ('q2', 'b'): 'q0'
        }

    def process_input(self, input_string):
        current_state = self.start_state
        for char in input_string:
            if (current_state, char) in self.transition_function:
                current_state = self.transition_function[(current_state, char)]
            else:
                return False  # 入力が無効な場合
        return current_state in self.accept_states

# 使用例
dfa = DFA()

# 入力文字列をテスト
test_strings = ['ab', 'ba', 'aab', 'bba', 'aaa']
for string in test_strings:
    result = dfa.process_input(string)
    print(f'入力 "{string}" は受理されますか? {result}')

```

```

def calculate_mips(clock_frequency, cycles_per_instruction):
    """
    クロック周波数と1命令あたりのクロックサイクル数からMIPSを計算します。
    
    Parameters:
    - clock_frequency: クロック周波数（Hz）
    - cycles_per_instruction: 1命令あたりのクロックサイクル数
    
    Returns:
    - MIPS: Million Instructions Per Second
    """
    # 1秒間に実行できる命令数を計算
    instructions_per_second = clock_frequency / cycles_per_instruction
    
    # MIPSを計算
    mips = instructions_per_second * 1e-6
    
    return mips

def calculate_instruction_execution_time(cycles_per_instruction, clock_frequency):
    """
    1命令あたりの平均実行時間を計算します。
    
    Parameters:
    - cycles_per_instruction: 1命令あたりのクロックサイクル数
    - clock_frequency: クロック周波数（Hz）
    
    Returns:
    - average_instruction_time: 平均命令実行時間（秒）
    """
    # 平均命令実行時間を計算
    average_instruction_time = cycles_per_instruction / clock_frequency
    
    return average_instruction_time

# 使用例
clock_frequency = 3.0e9  # 3 GHz
cycles_per_instruction = 4  # 1命令あたり4クロックサイクル

mips = calculate_mips(clock_frequency, cycles_per_instruction)
average_instruction_time = calculate_instruction_execution_time(cycles_per_instruction, clock_frequency)

print(f'クロック周波数: {clock_frequency / 1e9} GHz')
print(f'1命令あたりのクロックサイクル数: {cycles_per_instruction}')
print(f'MIPS: {mips:.2f} MIPS')
print(f'平均命令実行時間: {average_instruction_time:.2e} 秒')

```


```
def sequential_processing_time(num_instructions, cycle_time):
    """
    逐次制御の処理時間を計算します。
    
    Parameters:
    - num_instructions: 命令の総数
    - cycle_time: 各命令の処理時間（秒）
    
    Returns:
    - total_time: 全体の処理時間（秒）
    """
    total_time = num_instructions * cycle_time
    return total_time

def pipelined_throughput(num_stages, cycle_time):
    """
    パイプライン処理のスループットを計算します。
    
    Parameters:
    - num_stages: パイプラインステージの数
    - cycle_time: 各ステージのサイクル時間（秒）
    
    Returns:
    - throughput: パイプライン処理のスループット（命令/秒）
    """
    # 理想的なスループットは、各サイクルで1命令が処理される
    throughput = 1 / cycle_time
    return throughput

def pipelined_processing_time(num_instructions, num_stages, cycle_time):
    """
    パイプライン処理の全体の処理時間を計算します。
    
    Parameters:
    - num_instructions: 命令の総数
    - num_stages: パイプラインステージの数
    - cycle_time: 各ステージのサイクル時間（秒）
    
    Returns:
    - total_time: 全体の処理時間（秒）
    """
    # 各命令が全てのステージを通過するのにかかる時間
    total_time = (num_instructions + num_stages - 1) * cycle_time
    return total_time

# 使用例
num_instructions = 1000
cycle_time = 0.01  # 10ミリ秒

# 逐次制御の処理時間
sequential_time = sequential_processing_time(num_instructions, cycle_time)
print(f'逐次制御の処理時間: {sequential_time:.2f} 秒')

# パイプライン処理のスループット
num_stages = 5
pipelined_throughput = pipelined_throughput(num_stages, cycle_time)
print(f'パイプライン処理のスループット: {pipelined_throughput:.2f} 命令/秒')

# パイプライン処理の全体の処理時間
pipelined_time = pipelined_processing_time(num_instructions, num_stages, cycle_time)
print(f'パイプライン処理の全体の処理時間: {pipelined_time:.2f} 秒')


```


```
import numpy as np

def generate_hamming_code(data_bits):
    """
    ハミング符号を生成します。
    
    Parameters:
    - data_bits: データビットのリスト（例: [1, 0, 1, 1]）
    
    Returns:
    - codeword: ハミング符号化されたコードワード
    """
    m = len(data_bits)
    r = 0
    
    # 追加する冗長ビットの数を決定
    while (2 ** r) < (m + r + 1):
        r += 1
    
    # 初期のコードワード
    codeword = [0] * (m + r)
    
    j = 0
    for i in range(1, len(codeword) + 1):
        if (i & (i - 1)) == 0:
            # 冗長ビットの位置に設定
            continue
        else:
            codeword[i - 1] = data_bits[j]
            j += 1
    
    # 冗長ビットを計算して設定
    for i in range(r):
        parity_bit = 0
        for j in range(1, len(codeword) + 1):
            if j & (1 << i):
                parity_bit ^= codeword[j - 1]
        codeword[(1 << i) - 1] = parity_bit
    
    return codeword

def detect_and_correct_error(codeword):
    """
    ハミング符号でエラーを検出し、訂正します。
    
    Parameters:
    - codeword: 受信したコードワード（例: [1, 0, 1, 1, 0, 1, 0, 1]）
    
    Returns:
    - corrected_codeword: 訂正されたコードワード
    - error_position: エラーがあった位置（1-indexed）
    """
    r = 0
    while (1 << r) <= len(codeword):
        r += 1
    
    # エラーチェック
    error_position = 0
    for i in range(r):
        parity_bit = 0
        for j in range(1, len(codeword) + 1):
            if j & (1 << i):
                parity_bit ^= codeword[j - 1]
        if parity_bit != 0:
            error_position += (1 << i)
    
    # エラー訂正
    if error_position > 0 and error_position <= len(codeword):
        codeword[error_position - 1] ^= 1
    
    return codeword, error_position

# 使用例
data_bits = [1, 0, 1, 1]
codeword = generate_hamming_code(data_bits)
print(f'生成されたハミング符号: {codeword}')

# テスト用に故意にビットを変更
received_codeword = codeword.copy()
received_codeword[2] ^= 1  # エラーを注入

corrected_codeword, error_position = detect_and_correct_error(received_codeword)
print(f'受信したコードワード: {received_codeword}')
print(f'訂正されたコードワード: {corrected_codeword}')
print(f'エラーの位置: {error_position}')


```

```
def calculate_cache_hit_rate(cache_hits, cache_requests):
    """
    キャッシュヒット率を計算します。
    
    Parameters:
    - cache_hits: キャッシュヒット数
    - cache_requests: キャッシュリクエスト数
    
    Returns:
    - cache_hit_rate: キャッシュヒット率（%）
    """
    if cache_requests == 0:
        return 0  # リクエスト数がゼロの場合はヒット率は0%
    
    cache_hit_rate = (cache_hits / cache_requests) * 100
    return cache_hit_rate

# 使用例
cache_hits = 850
cache_requests = 1000

cache_hit_rate = calculate_cache_hit_rate(cache_hits, cache_requests)
print(f'キャッシュヒット率: {cache_hit_rate:.2f} %')


```


```
def calculate_capacity(vendor_gb):
    # 販売時の1GB = 1000³ バイト
    vendor_bytes = vendor_gb * 1000**3
    
    # Windows/Macの1GB = 1024³ バイト
    windows_mac_gb = vendor_bytes / (1024**3)
    
    return windows_mac_gb

def display_capacity_comparison(vendor_gb):
    windows_mac_gb = calculate_capacity(vendor_gb)
    
    print(f"販売時の容量: {vendor_gb} GB")
    print(f"Windows/Mac上での表示容量: {windows_mac_gb:.2f} GB")

# ハードディスクの販売時の容量（GB）
vendor_capacity_gb = 500  # 例として500GBのハードディスク

display_capacity_comparison(vendor_capacity_gb)


```


```
def calculate_total_average_time(seek_times, search_times, transfer_times):
    # 各時間の平均を計算
    average_seek_time = sum(seek_times) / len(seek_times)
    average_search_time = sum(search_times) / len(search_times)
    average_transfer_time = sum(transfer_times) / len(transfer_times)
    
    # 合計平均時間を計算
    total_average_time = average_seek_time + average_search_time + average_transfer_time
    
    return total_average_time

# 例としてのシーク時間、サーチ時間、転送時間
seek_times = [8, 9, 7, 10]  # 単位はミリ秒
search_times = [5, 6, 4, 7]
transfer_times = [2, 3, 2, 3]

total_average_time = calculate_total_average_time(seek_times, search_times, transfer_times)
print(f"合計平均時間: {total_average_time:.2f} ミリ秒")


```

```
def calculate_availability(uptime, downtime):
    """
    システムの稼働率を計算する関数。
    
    :param uptime: システムが稼働している時間（時間単位）
    :param downtime: システムが停止している時間（時間単位）
    :return: 稼働率（％）
    """
    # 稼働率の計算
    availability = uptime / (uptime + downtime)
    
    # パーセンテージに変換
    availability_percent = availability * 100
    
    return availability_percent

# 例として、稼働時間と停止時間を設定（時間単位）
uptime = 1000  # 稼働時間（時間）
downtime = 5   # 停止時間（時間）

# 稼働率の計算
availability_percent = calculate_availability(uptime, downtime)
print(f"システムの稼働率: {availability_percent:.2f}%")


```



```
def calculate_transmission_time(data_size, bandwidth):
    """
    データ伝送時間を計算する関数。
    
    :param data_size: データサイズ（ビット単位）
    :param bandwidth: 伝送速度（bps: ビット毎秒）
    :return: データ伝送時間（秒）
    """
    # データ伝送時間の計算
    transmission_time = data_size / bandwidth
    return transmission_time

# 例としてデータサイズと伝送速度を設定
data_size_mb = 100  # データサイズ（メガバイト）
bandwidth_mbps = 50  # 伝送速度（Mbps）

# データサイズをビットに変換（1MB = 8,000,000ビット）
data_size_bits = data_size_mb * 8 * 10**6

# 伝送速度をbpsに変換（1Mbps = 1,000,000 bps）
bandwidth_bps = bandwidth_mbps * 10**6

# データ伝送時間の計算
transmission_time = calculate_transmission_time(data_size_bits, bandwidth_bps)
print(f"データ伝送時間: {transmission_time:.2f} 秒")


```


```

def calculate_rotation_time(rpm):
    """
    1回転にかかる時間を計算する関数。
    
    :param rpm: 1分間の回転数 (Revolutions Per Minute)
    :return: 1回転にかかる時間（ミリ秒）
    """
    # 1分間（60秒 = 60,000ミリ秒）における1回転の時間を計算
    rotation_time = 60000 / rpm
    return rotation_time

def calculate_average_rotation_wait_time(rotation_time):
    """
    平均回転待ち時間を計算する関数。
    
    :param rotation_time: 1回転にかかる時間（ミリ秒）
    :return: 平均回転待ち時間（ミリ秒）
    """
    # 平均待ち時間は0.5回転分
    return rotation_time / 2

def calculate_transfer_time(data_size_bytes, bytes_per_track, rotation_time):
    """
    データ転送時間を計算する関数。
    
    :param data_size_bytes: 転送するデータサイズ（バイト）
    :param bytes_per_track: 1トラックあたりに記録できるバイト数
    :param rotation_time: 1回転にかかる時間（ミリ秒）
    :return: データ転送時間（ミリ秒）
    """
    # データ転送時間はデータサイズ / 1トラックあたりのバイト数 * 1回転あたりの時間
    transfer_time = (data_size_bytes / bytes_per_track) * rotation_time
    return transfer_time

def calculate_access_time(seek_time, rotation_time, data_size_bytes, bytes_per_track):
    """
    アクセス時間を計算する関数。
    
    :param seek_time: 平均シーク時間（ミリ秒）
    :param rotation_time: 1回転にかかる時間（ミリ秒）
    :param data_size_bytes: 転送するデータサイズ（バイト）
    :param bytes_per_track: 1トラックあたりに記録できるバイト数
    :return: アクセス時間（ミリ秒）
    """
    # 平均回転待ち時間を計算
    avg_rotation_wait_time = calculate_average_rotation_wait_time(rotation_time)
    
    # データ転送時間を計算
    transfer_time = calculate_transfer_time(data_size_bytes, bytes_per_track, rotation_time)
    
    # アクセス時間 = シーク時間 + 平均回転待ち時間 + データ転送時間
    access_time = seek_time + avg_rotation_wait_time + transfer_time
    
    return access_time

# 練習2と練習3の条件
seek_time_2 = 0  # シーク時間は練習2では指定されていない
seek_time_3 = 20  # ミリ秒
rpm_2 = 10800  # 練習2の回転数（回転/分）
rpm_3 = 5000  # 練習3の回転数（回転/分）
data_size_3 = 4000  # 練習3で転送するデータサイズ（バイト）
bytes_per_track_3 = 15000  # 練習3で1トラックに記録できるバイト数

# 練習2の計算
rotation_time_2 = calculate_rotation_time(rpm_2)
avg_rotation_wait_time_2 = calculate_average_rotation_wait_time(rotation_time_2)
print(f"練習2の平均回転待ち時間: {avg_rotation_wait_time_2:.2f} ミリ秒")

# 練習3の計算
rotation_time_3 = calculate_rotation_time(rpm_3)
access_time_3 = calculate_access_time(seek_time_3, rotation_time_3, data_size_3, bytes_per_track_3)
print(f"練習3のアクセス時間: {access_time_3:.2f} ミリ秒")

```

```

import ipaddress

def calculate_network_info(ip, subnet_mask):
    """
    IPアドレスとサブネットマスクからネットワークアドレスとブロードキャストアドレスを計算する関数。
    
    :param ip: IPアドレス（例："192.168.1.10"）
    :param subnet_mask: サブネットマスク（例："255.255.255.0"）
    :return: ネットワークアドレス、ブロードキャストアドレス
    """
    # IPアドレスとサブネットマスクを組み合わせてIPネットワークオブジェクトを作成
    network = ipaddress.IPv4Network(f"{ip}/{subnet_mask}", strict=False)
    
    # ネットワークアドレスとブロードキャストアドレスを取得
    network_address = network.network_address
    broadcast_address = network.broadcast_address
    
    return network_address, broadcast_address

# IPアドレスとサブネットマスクを指定
ip = "192.168.1.10"
subnet_mask = "255.255.255.0"

# ネットワークアドレスとブロードキャストアドレスを計算
network_address, broadcast_address = calculate_network_info(ip, subnet_mask)

# 結果を表示
print(f"IPアドレス: {ip}")
print(f"サブネットマスク: {subnet_mask}")
print(f"ネットワークアドレス: {network_address}")
print(f"ブロードキャストアドレス: {broadcast_address}")

```


```

def process_number():
    # 順次処理: ユーザーから整数を入力してもらう
    number = int(input("整数を入力してください: "))

    # 選択処理: 入力された整数が正か負かを判定
    if number > 0:
        print(f"{number} は正の数です。")
    elif number < 0:
        print(f"{number} は負の数です。")
    else:
        print(f"{number} はゼロです。")
    
    # 前判定繰り返し: 正の整数の場合、1からその数までの合計を計算する
    if number > 0:
        sum_total = 0
        i = 1
        while i <= number:
            sum_total += i
            i += 1
        print(f"1から{number}までの合計は {sum_total} です。")

# メイン関数を呼び出す
process_number()

```



```
import matplotlib.pyplot as plt

def arrow_diagram(tasks, dependencies):
    fig, ax = plt.subplots()

    # タスクを並べる
    y_pos = 1
    task_positions = {}

    for task in tasks:
        task_positions[task] = (0.1, y_pos)
        plt.text(0.05, y_pos, task, ha='right', va='center', fontsize=12)
        y_pos -= 0.2

    # 依存関係に基づいて矢印を描画
    for task, dependency in dependencies:
        start_pos = task_positions[dependency]
        end_pos = task_positions[task]
        
        ax.annotate("",
                    xy=(0.1, end_pos[1]), xycoords='data',
                    xytext=(0.1, start_pos[1]), textcoords='data',
                    arrowprops=dict(arrowstyle="->", lw=1.5, color="blue"))

    plt.ylim(0, 1.5)
    plt.xlim(0, 1)
    plt.axis('off')
    plt.title("Arrow Diagram")

    plt.show()

# タスクのリスト
tasks = ['Start', 'Task 1', 'Task 2', 'Task 3', 'End']

# 依存関係（矢印の接続元と接続先）
dependencies = [('Task 1', 'Start'), 
                ('Task 2', 'Task 1'), 
                ('Task 3', 'Task 2'), 
                ('End', 'Task 3')]

# アローダイヤグラムを描画
arrow_diagram(tasks, dependencies)

```

```
import matplotlib.pyplot as plt
import numpy as np

# EVM values: Planned Value (PV), Earned Value (EV), Actual Cost (AC), Budget at Completion (BAC)
PV = np.array([100, 200, 300, 400, 500])  # Example data for Planned Value
EV = np.array([90, 190, 280, 370, 450])   # Example data for Earned Value
AC = np.array([80, 210, 290, 380, 480])   # Example data for Actual Cost
BAC = 500  # Budget at Completion

# Calculating EVM metrics
SV = EV - PV  # Schedule Variance
CV = EV - AC  # Cost Variance
SPI = EV / PV  # Schedule Performance Index
CPI = EV / AC  # Cost Performance Index
ETC = (BAC - EV[-1]) / CPI[-1]  # Estimate to Complete
EAC = AC[-1] + ETC  # Estimate at Completion
VAC = BAC - EAC  # Variance at Completion

# Display calculated values
print(f"Schedule Variance (SV): {SV}")
print(f"Cost Variance (CV): {CV}")
print(f"Schedule Performance Index (SPI): {SPI}")
print(f"Cost Performance Index (CPI): {CPI}")
print(f"Estimate to Complete (ETC): {ETC}")
print(f"Estimate at Completion (EAC): {EAC}")
print(f"Variance at Completion (VAC): {VAC}")

# Plotting the EVM metrics
plt.figure(figsize=(10, 6))
time = np.arange(1, len(PV) + 1)

plt.plot(time, PV, label='Planned Value (PV)', marker='o', color='blue')
plt.plot(time, EV, label='Earned Value (EV)', marker='o', color='green')
plt.plot(time, AC, label='Actual Cost (AC)', marker='o', color='red')

plt.title('Earned Value Management (EVM) Metrics')
plt.xlabel('Time Period')
plt.ylabel('Cost (in units)')
plt.legend()
plt.grid(True)
plt.show()


```



```

import numpy as np
import matplotlib.pyplot as plt

# Parameters for the logistic growth model
K = 1000  # Carrying capacity (maximum population)
P0 = 10   # Initial population
r = 0.1   # Growth rate
time = np.linspace(0, 100, 500)  # Time range

# Logistic growth function
def logistic_growth(t, K, P0, r):
    return K / (1 + ((K - P0) / P0) * np.exp(-r * t))

# Derivative of logistic growth function
def logistic_growth_derivative(t, K, P0, r):
    P = logistic_growth(t, K, P0, r)
    return r * P * (1 - P / K)

# Calculate logistic growth and its derivative
population = logistic_growth(time, K, P0, r)
growth_rate = logistic_growth_derivative(time, K, P0, r)

# Plot logistic growth curve
plt.figure(figsize=(10, 6))
plt.plot(time, population, label='Logistic Growth (P(t))', color='blue', linewidth=2)
plt.plot(time, growth_rate, label='Growth Rate (dP/dt)', color='red', linestyle='--')
plt.title('Logistic Growth Curve and Its Derivative')
plt.xlabel('Time')
plt.ylabel('Population / Growth Rate')
plt.grid(True)
plt.legend()
plt.show()

```


```
import numpy as np
import matplotlib.pyplot as plt

# サンプルデータ生成（ここではランダムデータを使用）
np.random.seed(42)
data = np.random.normal(loc=50, scale=2, size=30)  # 平均50、標準偏差2のデータ

# 管理図の要素
CL = np.mean(data)  # 中心線（プロセスの平均）
UCL = CL + 3 * np.std(data)  # 上方管理限界
LCL = CL - 3 * np.std(data)  # 下方管理限界

# 管理図をプロット
plt.figure(figsize=(10, 6))
plt.plot(data, marker='o', linestyle='-', color='blue', label='Process Data')

# 中心線
plt.axhline(y=CL, color='green', linestyle='-', label='Center Line (CL)')
# 上方管理限界
plt.axhline(y=UCL, color='red', linestyle='--', label='Upper Control Limit (UCL)')
# 下方管理限界
plt.axhline(y=LCL, color='red', linestyle='--', label='Lower Control Limit (LCL)')

# グラフ設定
plt.title('Control Chart for Quality Management')
plt.xlabel('Sample')
plt.ylabel('Measurement Value')
plt.grid(True)
plt.legend()
plt.show()




```

```
import numpy as np
import matplotlib.pyplot as plt

# サンプルデータ（カテゴリとそれに対応する数値）
categories = ['Category A', 'Category B', 'Category C', 'Category D', 'Category E']
values = [50, 30, 15, 10, 5]  # 各カテゴリの頻度

# データの並び替え（降順に）
sorted_indices = np.argsort(values)[::-1]
sorted_categories = [categories[i] for i in sorted_indices]
sorted_values = np.array([values[i] for i in sorted_indices])

# 累積比率を計算
cumulative_percent = np.cumsum(sorted_values) / np.sum(sorted_values) * 100

# パレート図を描画
fig, ax1 = plt.subplots(figsize=(10, 6))

# 棒グラフ（カテゴリごとの頻度）
ax1.bar(sorted_categories, sorted_values, color='C0')
ax1.set_xlabel('Categories')
ax1.set_ylabel('Frequency', color='C0')
ax1.tick_params('y', colors='C0')

# 累積比率の折れ線グラフ
ax2 = ax1.twinx()
ax2.plot(sorted_categories, cumulative_percent, color='C1', marker='o', linestyle='-', linewidth=2)
ax2.set_ylabel('Cumulative Percentage', color='C1')
ax2.tick_params('y', colors='C1')

# 累積比率に80%のラインを追加
ax2.axhline(y=80, color='red', linestyle='--', label='80% Line')
ax2.legend(loc='best')

# グラフのタイトルとレイアウト調整
plt.title('Pareto Chart with Cumulative Percentage')
fig.tight_layout()
plt.show()


```


```
# 画面数の定義
small_simple = 30
medium_normal = 40
large_normal = 20
large_complex = 10

# 作成工数の定義 (人日)
small_simple_cost = 0.4
medium_normal_cost = 0.6
large_normal_cost = 0.8
large_complex_cost = 1.2

# 画面ごとの作成工数の計算
total_creation_cost = (small_simple * small_simple_cost) + \
                      (medium_normal * medium_normal_cost) + \
                      (large_normal * large_normal_cost) + \
                      (large_complex * large_complex_cost)

# レビューと修正に要する工数
review_and_fix_cost = 5

# 管理工数（作業工数の20%）
management_cost = 0.2 * (total_creation_cost + review_and_fix_cost)

# 総工数の計算
total_cost = total_creation_cost + review_and_fix_cost + management_cost

# 結果を出力
print(f"全ての画面を作成する総工数は {total_cost:.1f} 人日です。")


```


```

import numpy as np
import matplotlib.pyplot as plt

# 使用量の定義
usage = np.linspace(0, 100, 500)

# 逓減課金方式の料金設定
def declining_rate_pricing(usage):
    if usage <= 20:
        return usage * 5  # 最初の20単位は5円/単位
    elif usage <= 50:
        return 20 * 5 + (usage - 20) * 4  # 次の30単位は4円/単位
    elif usage <= 80:
        return 20 * 5 + 30 * 4 + (usage - 50) * 3  # 次の30単位は3円/単位
    else:
        return 20 * 5 + 30 * 4 + 30 * 3 + (usage - 80) * 2  # それ以上は2円/単位

# 各使用量に対する料金を計算
pricing = np.array([declining_rate_pricing(u) for u in usage])

# グラフの描画
plt.figure(figsize=(10, 6))
plt.plot(usage, pricing, label="Declining Rate Pricing", color='blue')
plt.title("Declining Rate Pricing for IT Service Usage")
plt.xlabel("Usage (units)")
plt.ylabel("Price (yen)")
plt.grid(True)
plt.legend()
plt.show()



```

```

import numpy as np
import matplotlib.pyplot as plt

# サンプルデータ
np.random.seed(42)
n = 30
x = np.random.rand(n) * 100  # x座標
y = np.random.rand(n) * 100  # y座標
sizes = np.random.rand(n) * 1000  # バブルの大きさ（ランダムな値）

# バブルチャートの描画
plt.figure(figsize=(10, 6))
plt.scatter(x, y, s=sizes, c=x, cmap='viridis', alpha=0.6, edgecolors='w', linewidth=2)

# グラフの設定
plt.title('Bubble Chart Example')
plt.xlabel('X Axis Label')
plt.ylabel('Y Axis Label')
plt.colorbar(label='Color Scale (Based on X values)')  # カラーバーを追加
plt.grid(True)

# グラフを表示
plt.show()

```


```
import numpy as np
import matplotlib.pyplot as plt

# Parameters for the power-law distribution
total_products = 1000  # Total number of products
x = np.arange(1, total_products + 1)  # Product rank from most popular to least
C = 100  # Scaling constant
alpha = 1.5  # Power-law exponent (controls how sales decline)

# Sales volume follows a power-law distribution
sales_volume = C / (x ** alpha)

# Plotting the sales distribution
plt.figure(figsize=(10, 6))
plt.plot(x, sales_volume, label='Sales Volume (Long Tail)', color='blue')
plt.xscale('log')  # Logarithmic scale for product rank
plt.yscale('log')  # Logarithmic scale for sales volume
plt.xlabel('Product Rank (log scale)', fontsize=12)
plt.ylabel('Sales Volume (log scale)', fontsize=12)
plt.title('Long Tail Sales Distribution', fontsize=16)
plt.legend()
plt.grid(True, which='both', linestyle='--')

# Show the plot
plt.show()


```


```
import numpy as np
import matplotlib.pyplot as plt

# Parameters
order_interval = 10  # Order interval (e.g., order every 10 days)
order_amount = 100  # Order quantity
initial_stock = 50  # Initial stock level
daily_demand = 5  # Daily demand

# Simulation settings
days = 100  # Number of days for simulation
stock = np.zeros(days)  # Array to record stock levels
stock[0] = initial_stock

# Simulation
for day in range(1, days):
    # Subtract daily demand from previous day's stock
    stock[day] = stock[day - 1] - daily_demand
    
    # Place an order based on the order interval
    if day % order_interval == 0:
        stock[day] += order_amount

# Plot
plt.figure(figsize=(12, 6))
plt.plot(stock, marker='o', linestyle='-', color='b')
plt.title('Stock Level Variation with Periodic Ordering')
plt.xlabel('Days')
plt.ylabel('Stock Level')
plt.grid(True)
plt.show()
```

```
import numpy as np
import matplotlib.pyplot as plt

# Parameters
reorder_point = 20  # Reorder point
order_amount = 100  # Order quantity
initial_stock = 50  # Initial stock level
daily_demand = 5  # Daily demand

# Simulation settings
days = 100  # Number of days for simulation
stock = np.zeros(days)  # Array to record stock levels
stock[0] = initial_stock

# Simulation
for day in range(1, days):
    # Subtract daily demand from previous day's stock
    stock[day] = stock[day - 1] - daily_demand
    
    # Place an order if stock falls below the reorder point
    if stock[day] < reorder_point:
        stock[day] += order_amount

# Plot
plt.figure(figsize=(12, 6))
plt.plot(stock, marker='o', linestyle='-', color='r')
plt.title('Stock Level Variation with Reorder Point Ordering')
plt.xlabel('Days')
plt.ylabel('Stock Level')
plt.grid(True)
plt.show()

```


```

import numpy as np
import matplotlib.pyplot as plt

# Parameters
D = 10000  # Annual demand
S = 50     # Cost per order
H = 2      # Holding cost per unit per year

# EOQ Calculation
EOQ = np.sqrt((2 * D * S) / H)

# Define a range of order quantities
order_quantities = np.linspace(0, 2 * EOQ, 500)

# Calculate total cost for each order quantity
def total_cost(Q):
    return (D / Q) * S + (Q / 2) * H

total_costs = total_cost(order_quantities)

# Plotting
plt.figure(figsize=(10, 6))
plt.plot(order_quantities, total_costs, label='Total Cost', color='blue')
plt.axvline(x=EOQ, color='red', linestyle='--', label='EOQ')
plt.xlabel('Order Quantity')
plt.ylabel('Total Cost')
plt.title('Total Cost vs. Order Quantity')
plt.legend()
plt.grid(True)
plt.show()

```


```
import matplotlib.pyplot as plt
import numpy as np

# データ設定
categories = ['A', 'B', 'C', 'D', 'E']
values = [50, 30, 15, 5, 1]

# データを降順にソート
sorted_indices = np.argsort(values)[::-1]
sorted_values = np.array(values)[sorted_indices]
sorted_categories = np.array(categories)[sorted_indices]

# パレート図の作成
plt.figure(figsize=(10, 6))
plt.bar(sorted_categories, sorted_values, color='b')
plt.xlabel('Category')
plt.ylabel('Frequency')
plt.title('Pareto Chart')
plt.show()


```

```
import matplotlib.pyplot as plt

# フィッシュボーン図の作成
fig, ax = plt.subplots(figsize=(12, 8))
ax.plot([0, 1], [0, 0], 'k', lw=2)  # 主軸
ax.plot([0.5, 0.5], [0.1, -0.1], 'k', lw=2)  # 魚の骨
ax.text(0.5, 0.05, 'Main Problem', fontsize=12, ha='center')

# 魚の骨の枝
branches = ['Machine', 'Method', 'Material', 'Measurement', 'Manpower', 'Environment']
for i, branch in enumerate(branches):
    ax.plot([0.5, 0.4 - i*0.1], [0.0, 0.1], 'k', lw=2)
    ax.text(0.4 - i*0.1, 0.1, branch, fontsize=10, ha='center')

plt.xlim(0, 1)
plt.ylim(-0.2, 0.2)
plt.axis('off')
plt.title('Fishbone Diagram')
plt.show()

```


```
import matplotlib.pyplot as plt

# データ設定
x = np.random.rand(50)
y = 2 * x + np.random.normal(0, 0.1, 50)

# 散布図の作成
plt.figure(figsize=(10, 6))
plt.scatter(x, y, color='r', label='Data Points')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.title('Scatter Diagram')
plt.legend()
plt.grid(True)
plt.show()


```


```

import matplotlib.pyplot as plt

# データ設定
data = np.random.normal(loc=0, scale=1, size=1000)

# ヒストグラムの作成
plt.figure(figsize=(10, 6))
plt.hist(data, bins=30, color='g', edgecolor='black')
plt.xlabel('Value')
plt.ylabel('Frequency')
plt.title('Histogram')
plt.grid(True)
plt.show()

```


```
import matplotlib.pyplot as plt

# データ設定
np.random.seed(0)
data = np.random.normal(loc=50, scale=5, size=100)
mean = np.mean(data)
std_dev = np.std(data)

# 管理図の作成
plt.figure(figsize=(12, 6))
plt.plot(data, label='Data', color='blue')
plt.axhline(mean, color='green', linestyle='--', label='Mean')
plt.axhline(mean + 3*std_dev, color='red', linestyle='--', label='Upper Control Limit')
plt.axhline(mean - 3*std_dev, color='red', linestyle='--', label='Lower Control Limit')
plt.xlabel('Sample')
plt.ylabel('Value')
plt.title('Control Chart')
plt.legend()
plt.grid(True)
plt.show()

```


```

import matplotlib.pyplot as plt

# サンプルデータ
categories = ['Defect A', 'Defect B', 'Defect C']
counts = [30, 15, 5]

# チェックシートのプロット（棒グラフとして）
plt.figure(figsize=(10, 6))
plt.bar(categories, counts, color='purple')
plt.xlabel('Defect Type')
plt.ylabel('Count')
plt.title('Check Sheet')
plt.show()

```


```
import matplotlib.pyplot as plt

# 因果関係図の作成
fig, ax = plt.subplots(figsize=(12, 8))
ax.plot([0, 1], [0, 0], 'k', lw=2)  # 主軸
ax.plot([0.5, 0.4], [0.0, 0.1], 'k', lw=2)  # 主要原因
ax.plot([0.5, 0.6], [0.0, 0.1], 'k', lw=2)  # 主要原因
ax.text(0.5, 0.05, 'Main Problem', fontsize=12, ha='center')

# 因果関係の枝
causes = ['Cause 1', 'Cause 2', 'Cause 3']
for i, cause in enumerate(causes):
    ax.plot([0.4 + i*0.2, 0.4 + i*0.2], [0.1, 0.2], 'k', lw=2)
    ax.text(0.4 + i*0.2, 0.22, cause, fontsize=10, ha='center')

plt.xlim(0, 1)
plt.ylim(-0.1, 0.3)
plt.axis('off')
plt.title('Cause and Effect Diagram')
plt.show()


```


```
import matplotlib.pyplot as plt
import numpy as np

# データ設定（カテゴリと金額）
categories = ['Item A', 'Item B', 'Item C', 'Item D', 'Item E']
amounts = [1000, 700, 300, 200, 100]

# データを降順にソート
sorted_indices = np.argsort(amounts)[::-1]
sorted_amounts = np.array(amounts)[sorted_indices]
sorted_categories = np.array(categories)[sorted_indices]

# 累積パーセンテージの計算
cumulative_amounts = np.cumsum(sorted_amounts)
total_amount = cumulative_amounts[-1]
cumulative_percentage = cumulative_amounts / total_amount * 100

# パレート図の作成
fig, ax1 = plt.subplots(figsize=(10, 6))

# バーグラフ（各カテゴリの金額）
color = 'tab:blue'
ax1.set_xlabel('Category')
ax1.set_ylabel('Amount', color=color)
ax1.bar(sorted_categories, sorted_amounts, color=color)
ax1.tick_params(axis='y', labelcolor=color)

# 折れ線グラフ（累積パーセンテージ）
ax2 = ax1.twinx()
color = 'tab:red'
ax2.set_ylabel('Cumulative Percentage (%)', color=color)
ax2.plot(sorted_categories, cumulative_percentage, color=color, marker='o', linestyle='--')
ax2.tick_params(axis='y', labelcolor=color)

# タイトルとレイアウト
plt.title('Pareto Chart')
fig.tight_layout()
plt.show()

```


```
import numpy as np
import matplotlib.pyplot as plt

# パラメータ設定
n = 100     # サンプルサイズ
c = 2       # 許容できる不良品数

# 不良率の範囲
p = np.linspace(0, 0.2, 100)

# 合格率の計算
def oc_curve(p, n, c):
    return 1 - (1 - p)**n

# OC曲線の計算
pass_rates = [1 - sum(np.math.comb(n, k) * (p_i**k) * ((1 - p_i)**(n - k)) for k in range(c + 1)) for p_i in p]

# プロット
plt.figure(figsize=(10, 6))
plt.plot(p, pass_rates, label='OC Curve', color='blue')
plt.xlabel('Lot Defect Rate (p)')
plt.ylabel('Probability of Passing the Lot')
plt.title('Operating Characteristic (OC) Curve')
plt.grid(True)
plt.legend()
plt.show()


```


```
import numpy as np
import matplotlib.pyplot as plt

# パラメータ設定
initial_cost = 10000  # 資産の取得原価
depreciation_rate = 0.2  # 減価償却率（例: 20%）
useful_life_years = 10  # 資産の耐用年数

# 初期化
book_value = initial_cost
depreciation_expenses = []
book_values = []

# 各年の減価償却費と簿価の計算
for year in range(useful_life_years):
    depreciation_expense = book_value * depreciation_rate
    depreciation_expenses.append(depreciation_expense)
    book_value -= depreciation_expense
    book_values.append(book_value)

# プロット
years = np.arange(1, useful_life_years + 1)

plt.figure(figsize=(10, 6))
plt.plot(years, book_values, marker='o', label='Book Value', color='blue')
plt.xlabel('Year')
plt.ylabel('Book Value')
plt.title('Declining Balance Method Depreciation')
plt.grid(True)
plt.legend()
plt.show()


```

```
import numpy as np

# CPU性能メトリクス
def calculate_mips(instruction_execution_time):
    return 1 / (instruction_execution_time * 1e-6)  # nMIPS

def average_instruction_execution_time(mips):
    return 1 / (mips * 1e6)  # 秒

def clock_cycle_time(clock_frequency_mhz):
    return 1 / (clock_frequency_mhz * 1e6)  # 秒

def average_instruction_execution_time_from_clock(clock_cycle_time, cycles_per_instruction):
    return clock_cycle_time * cycles_per_instruction  # 秒

# メモリアクセス時間
def cache_memory_access_time(hit_rate, cache_access_time):
    return hit_rate * cache_access_time

def main_memory_access_time(miss_rate, main_memory_access_time):
    return miss_rate * main_memory_access_time

def cpu_effective_access_time(cache_access_time, main_memory_access_time):
    return cache_access_time + main_memory_access_time

# VRAMと画像データ容量
def required_vram_capacity(total_pixels, color_info_bits):
    return total_pixels * color_info_bits  # ビット

def image_data_capacity(total_pixels, color_info_bits):
    return total_pixels * color_info_bits  # ビット

# 電力とバッテリー容量
def power_consumption(voltage, current):
    return voltage * current  # ワット

def battery_capacity(current, time_hours):
    return current * time_hours  # アンペア・アワー

# サンプルデータ
instruction_execution_time = 2e-8  # 秒
mips = calculate_mips(instruction_execution_time)
print(f"MIPS: {mips:.2f} million instructions per second")

clock_frequency_mhz = 3000  # MHz
cycles_per_instruction = 4
cycle_time = clock_cycle_time(clock_frequency_mhz)
avg_instr_exec_time = average_instruction_execution_time_from_clock(cycle_time, cycles_per_instruction)
print(f"Average Instruction Execution Time: {avg_instr_exec_time:.2e} seconds")

hit_rate = 0.95
cache_access_time = 1e-6  # 秒
main_memory_access_time_val = 10e-6  # 秒
cache_avg_time = cache_memory_access_time(hit_rate, cache_access_time)
main_memory_avg_time = main_memory_access_time(1 - hit_rate, main_memory_access_time_val)
effective_access_time = cpu_effective_access_time(cache_avg_time, main_memory_avg_time)
print(f"CPU Effective Access Time: {effective_access_time:.2e} seconds")

total_pixels = 1920 * 1080  # 画面解像度
color_info_bits = 24  # 24ビットカラー
vram_capacity = required_vram_capacity(total_pixels, color_info_bits)
image_capacity = image_data_capacity(total_pixels, color_info_bits)
print(f"Required VRAM Capacity: {vram_capacity / 8 / 1e6:.2f} MB")
print(f"Image Data Capacity: {image_capacity / 8 / 1e6:.2f} MB")

voltage = 5  # ボルト
current = 2  # アンペア
power = power_consumption(voltage, current)
print(f"Power Consumption: {power:.2f} W")

battery_current = 2  # アンペア
battery_time_hours = 5  # 時間
battery_capacity_val = battery_capacity(battery_current, battery_time_hours)
print(f"Battery Capacity: {battery_capacity_val:.2f} Ah")

```


```
def calculate_data_transmission_time(data_amount_bits, transmission_speed_bps, line_utilization):
    """
    Calculate the data transmission time.
    
    Parameters:
    data_amount_bits (int): Amount of data to be transmitted in bits.
    transmission_speed_bps (int): Data transmission speed in bits per second.
    line_utilization (float): Line utilization (between 0 and 1).
    
    Returns:
    float: Data transmission time in seconds.
    """
    return data_amount_bits / (transmission_speed_bps * line_utilization)

def calculate_line_utilization(effective_transmission_speed_bps, max_transmission_speed_bps):
    """
    Calculate the line utilization.
    
    Parameters:
    effective_transmission_speed_bps (int): Effective transmission speed in bits per second.
    max_transmission_speed_bps (int): Maximum possible transmission speed in bits per second.
    
    Returns:
    float: Line utilization (between 0 and 1).
    """
    return effective_transmission_speed_bps / max_transmission_speed_bps

# サンプルデータ
data_amount_bits = 50000000  # 伝送データ量 (ビット)
transmission_speed_bps = 100000000  # データ伝送速度 (ビット/秒)
effective_transmission_speed_bps = 75000000  # 実効伝送速度 (ビット/秒)

# 回線利用率の計算
line_utilization = calculate_line_utilization(effective_transmission_speed_bps, transmission_speed_bps)
print(f"Line Utilization: {line_utilization:.2f}")

# データ伝送時間の計算
transmission_time = calculate_data_transmission_time(data_amount_bits, transmission_speed_bps, line_utilization)
print(f"Data Transmission Time: {transmission_time:.2f} seconds")


```


```
import numpy as np
import matplotlib.pyplot as plt

def calculate_break_even_sales(fixed_costs, variable_costs_ratio):
    """
    Calculate the break-even sales revenue.
    
    Parameters:
    fixed_costs (float): Fixed costs.
    variable_costs_ratio (float): Variable costs ratio (0 to 1).
    
    Returns:
    float: Break-even sales revenue.
    """
    return fixed_costs / (1 - variable_costs_ratio)

def calculate_variable_costs_ratio(variable_costs, sales_revenue):
    """
    Calculate the variable costs ratio.
    
    Parameters:
    variable_costs (float): Variable costs.
    sales_revenue (float): Sales revenue.
    
    Returns:
    float: Variable costs ratio (0 to 1).
    """
    return variable_costs / sales_revenue

# サンプルデータ
fixed_costs = 50000  # 固定費
variable_costs = 30000  # 変動費
sales_revenue = 100000  # 売上高

# 変動費率の計算
variable_costs_ratio = calculate_variable_costs_ratio(variable_costs, sales_revenue)
print(f"Variable Costs Ratio: {variable_costs_ratio:.2f}")

# 損益分岐点売上高の計算
break_even_sales = calculate_break_even_sales(fixed_costs, variable_costs_ratio)
print(f"Break-even Sales Revenue: ${break_even_sales:.2f}")

# プロット
sales_range = np.linspace(0, 2 * sales_revenue, 100)
profit_or_loss = sales_range - (fixed_costs + variable_costs_ratio * sales_range)

plt.figure(figsize=(10, 6))
plt.plot(sales_range, profit_or_loss, label='Profit or Loss', color='blue')
plt.axhline(0, color='red', linestyle='--', label='Break-even Point')
plt.xlabel('Sales Revenue ($)')
plt.ylabel('Profit or Loss ($)')
plt.title('Break-even Analysis')
plt.legend()
plt.grid(True)
plt.show()


```

```
import numpy as np
import matplotlib.pyplot as plt

def calculate_maximum_profit(selling_price, variable_cost, expected_demand, fixed_costs):
    """
    Calculate the maximum profit.
    
    Parameters:
    selling_price (float): Selling price per unit.
    variable_cost (float): Variable cost per unit.
    expected_demand (float): Expected demand.
    fixed_costs (float): Fixed costs.
    
    Returns:
    float: Maximum profit.
    """
    return (selling_price - variable_cost) * expected_demand - fixed_costs

def calculate_expected_demand(selling_price, price_demand_intercept, price_demand_slope):
    """
    Calculate the expected demand based on the selling price.
    
    Parameters:
    selling_price (float): Selling price per unit.
    price_demand_intercept (float): Intercept of the price-demand line.
    price_demand_slope (float): Slope of the price-demand line.
    
    Returns:
    float: Expected demand.
    """
    return price_demand_intercept - price_demand_slope * selling_price

def calculate_expected_profit(selling_price, price_demand_intercept, price_demand_slope, variable_cost, fixed_costs):
    """
    Calculate the expected profit.
    
    Parameters:
    selling_price (float): Selling price per unit.
    price_demand_intercept (float): Intercept of the price-demand line.
    price_demand_slope (float): Slope of the price-demand line.
    variable_cost (float): Variable cost per unit.
    fixed_costs (float): Fixed costs.
    
    Returns:
    float: Expected profit.
    """
    expected_demand = calculate_expected_demand(selling_price, price_demand_intercept, price_demand_slope)
    return (selling_price - variable_cost) * expected_demand - fixed_costs

# サンプルデータ
selling_price = 120  # 設定価格
variable_cost = 60  # 変動費
expected_demand = 500  # 予想需要数
fixed_costs = 10000  # 固定費

# 最大利益の計算
max_profit = calculate_maximum_profit(selling_price, variable_cost, expected_demand, fixed_costs)
print(f"Maximum Profit: ${max_profit:.2f}")

# 期待利益の計算
price_demand_intercept = 1000  # 価格-需要線の切片
price_demand_slope = 5  # 価格-需要線の傾き

# 価格の範囲
price_range = np.linspace(50, 150, 100)
expected_profits = [calculate_expected_profit(price, price_demand_intercept, price_demand_slope, variable_cost, fixed_costs) for price in price_range]

# プロット
plt.figure(figsize=(10, 6))
plt.plot(price_range, expected_profits, label='Expected Profit', color='green')
plt.xlabel('Selling Price ($)')
plt.ylabel('Expected Profit ($)')
plt.title('Expected Profit vs Selling Price')
plt.axhline(0, color='red', linestyle='--', label='Break-even Point')
plt.legend()
plt.grid(True)
plt.show()

```


```
import numpy as np
import matplotlib.pyplot as plt

def reliability_series(reliabilities):
    """
    Calculate the reliability of a series system.
    
    Parameters:
    reliabilities (list of float): Reliability of each component in series.
    
    Returns:
    float: Reliability of the series system.
    """
    return np.prod(reliabilities)

def reliability_parallel(reliabilities):
    """
    Calculate the reliability of a parallel system.
    
    Parameters:
    reliabilities (list of float): Reliability of each component in parallel.
    
    Returns:
    float: Reliability of the parallel system.
    """
    return 1 - np.prod(1 - np.array(reliabilities))

# サンプルデータ
reliabilities = [0.9, 0.8, 0.7]  # 各コンポーネントの信頼性

# 直列システムの信頼性の計算
series_reliability = reliability_series(reliabilities)
print(f"Series System Reliability: {series_reliability:.2f}")

# 並列システムの信頼性の計算
parallel_reliability = reliability_parallel(reliabilities)
print(f"Parallel System Reliability: {parallel_reliability:.2f}")

# プロットの準備
reliability_range = np.linspace(0.1, 0.9, 100)
series_reliabilities = [reliability_series([r] * 3) for r in reliability_range]
parallel_reliabilities = [reliability_parallel([r] * 3) for r in reliability_range]

# プロット
plt.figure(figsize=(12, 6))
plt.plot(reliability_range, series_reliabilities, label='Series System Reliability', color='blue')
plt.plot(reliability_range, parallel_reliabilities, label='Parallel System Reliability', color='green')
plt.xlabel('Component Reliability')
plt.ylabel('System Reliability')
plt.title('System Reliability vs Component Reliability')
plt.legend()
plt.grid(True)
plt.show()


```


```

import networkx as nx
import matplotlib.pyplot as plt

def draw_tree():
    # Create a new directed graph
    G = nx.DiGraph()
    
    # Define the edges of the tree (parent, child)
    edges = [
        ('Root', 'Child 1'),
        ('Root', 'Child 2'),
        ('Child 1', 'Grandchild 1.1'),
        ('Child 1', 'Grandchild 1.2'),
        ('Child 2', 'Grandchild 2.1'),
        ('Child 2', 'Grandchild 2.2'),
        ('Grandchild 1.2', 'Great-Grandchild 1.2.1')
    ]
    
    # Add edges to the graph
    G.add_edges_from(edges)
    
    # Create a layout for the nodes (tree layout)
    pos = nx.spring_layout(G, seed=42)  # Use spring layout for better visualization
    
    # Draw the nodes and edges
    plt.figure(figsize=(10, 7))
    nx.draw(G, pos, with_labels=True, node_size=2000, node_color='skyblue', font_size=12, font_weight='bold', edge_color='gray')
    
    # Set the title
    plt.title('Tree Structure')
    
    # Show the plot
    plt.show()

# Call the function to draw the tree
draw_tree()

```


```


import numpy as np
import matplotlib.pyplot as plt

# Parameters
A_c = 1.0  # Carrier amplitude
A_m = 0.5  # Modulating signal amplitude
f_c = 5.0  # Carrier frequency (Hz)
f_m = 1.0  # Modulating frequency (Hz)
k_f = 1.0  # Frequency modulation sensitivity
k_p = np.pi  # Phase modulation sensitivity
t = np.linspace(0, 1, 1000)  # Time vector

# Modulating signal
m = A_m * np.sin(2 * np.pi * f_m * t)

# Amplitude Modulated Signal (AM)
s_am = (A_c + m) * np.cos(2 * np.pi * f_c * t)

# Frequency Modulated Signal (FM)
s_fm = A_c * np.cos(2 * np.pi * f_c * t + 2 * np.pi * k_f * np.cumsum(m) / 1000)

# Phase Modulated Signal (PM)
s_pm = A_c * np.cos(2 * np.pi * f_c * t + k_p * m)

# Quadrature Amplitude Modulated Signal (QAM)
A1 = A_m * np.cos(2 * np.pi * f_m * t)
A2 = A_m * np.sin(2 * np.pi * f_m * t)
s_qam = A1 * np.cos(2 * np.pi * f_c * t) + A2 * np.sin(2 * np.pi * f_c * t)

# Phase Shift Keying (PSK)
phi = np.pi * np.sin(2 * np.pi * f_m * t)  # Example phase shift
s_psk = A_c * np.cos(2 * np.pi * f_c * t + phi)

# Plotting
plt.figure(figsize=(14, 12))

# AM Signal
plt.subplot(5, 1, 1)
plt.plot(t, m, label='Modulating Signal')
plt.title('Modulating Signal')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.grid(True)

plt.subplot(5, 1, 2)
plt.plot(t, s_am, label='AM Signal', color='orange')
plt.title('Amplitude Modulated Signal (AM)')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.grid(True)

# FM Signal
plt.subplot(5, 1, 3)
plt.plot(t, s_fm, label='FM Signal', color='green')
plt.title('Frequency Modulated Signal (FM)')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.grid(True)

# PM Signal
plt.subplot(5, 1, 4)
plt.plot(t, s_pm, label='PM Signal', color='blue')
plt.title('Phase Modulated Signal (PM)')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.grid(True)

# QAM Signal
plt.subplot(5, 1, 5)
plt.plot(t, s_qam, label='QAM Signal', color='red')
plt.title('Quadrature Amplitude Modulated Signal (QAM)')
plt.xlabel('Time (s)')
plt.ylabel('Amplitude')
plt.grid(True)

plt.tight_layout()
plt.show()

```

```
import numpy as np
import matplotlib.pyplot as plt

# Parameters
t = np.linspace(0, 100, 1000)  # Time vector
initial_failure_rate = 0.2  # Initial failure rate (decreasing)
normal_failure_rate = 0.05   # Normal period failure rate
wearout_failure_rate = 0.1   # Wear-out period failure rate (increasing)
transition_point1 = 20       # Time when transition from initial to normal period occurs
transition_point2 = 70       # Time when transition from normal to wear-out period occurs

# Bathtub Curve
def bathtub_curve(t, initial_failure_rate, normal_failure_rate, wearout_failure_rate, transition_point1, transition_point2):
    failure_rate = np.zeros_like(t)
    
    # Initial failure period
    failure_rate[t < transition_point1] = initial_failure_rate * (1 - (t[t < transition_point1] / transition_point1))
    
    # Normal period
    failure_rate[(t >= transition_point1) & (t < transition_point2)] = normal_failure_rate
    
    # Wear-out period
    failure_rate[t >= transition_point2] = wearout_failure_rate * ((t[t >= transition_point2] - transition_point2) / (100 - transition_point2))

    return failure_rate

# Compute the failure rate
failure_rate = bathtub_curve(t, initial_failure_rate, normal_failure_rate, wearout_failure_rate, transition_point1, transition_point2)

# Plotting
plt.figure(figsize=(10, 6))
plt.plot(t, failure_rate, label='Bathtub Curve', color='purple')
plt.title('Bathtub Curve')
plt.xlabel('Time')
plt.ylabel('Failure Rate')
plt.grid(True)
plt.legend()
plt.show()

```


```
import numpy as np
import matplotlib.pyplot as plt

# Parameters
t = np.linspace(0, 100, 1000)  # Time vector
uptime_initial = 10            # Initial uptime (constant)
downtime_initial = 5           # Initial downtime (constant)
uptime_normal = 95             # Normal uptime rate (constant)
downtime_normal = 5            # Normal downtime rate (constant)
uptime_wearout = 90            # Wear-out uptime rate (decreasing)
downtime_wearout = 10          # Wear-out downtime rate (increasing)
transition_point1 = 20        # Time when transition from initial to normal period occurs
transition_point2 = 70        # Time when transition from normal to wear-out period occurs

# Uptime and Downtime Calculation
def uptime_downtime(t, uptime_initial, downtime_initial, uptime_normal, downtime_normal, uptime_wearout, downtime_wearout, transition_point1, transition_point2):
    uptime = np.zeros_like(t)
    downtime = np.zeros_like(t)
    
    # Initial phase
    uptime[t < transition_point1] = uptime_initial * (t[t < transition_point1] / transition_point1)
    downtime[t < transition_point1] = downtime_initial * (t[t < transition_point1] / transition_point1)
    
    # Normal phase
    uptime[(t >= transition_point1) & (t < transition_point2)] = uptime_normal * (t[(t >= transition_point1) & (t < transition_point2)] - transition_point1) + uptime_initial
    downtime[(t >= transition_point1) & (t < transition_point2)] = downtime_normal * (t[(t >= transition_point1) & (t < transition_point2)] - transition_point1) + downtime_initial
    
    # Wear-out phase
    uptime[t >= transition_point2] = uptime_wearout * ((t[t >= transition_point2] - transition_point2) / (100 - transition_point2)) + uptime_normal
    downtime[t >= transition_point2] = downtime_wearout * ((t[t >= transition_point2] - transition_point2) / (100 - transition_point2)) + downtime_normal
    
    return uptime, downtime

# Compute uptime and downtime
uptime, downtime = uptime_downtime(t, uptime_initial, downtime_initial, uptime_normal, downtime_normal, uptime_wearout, downtime_wearout, transition_point1, transition_point2)

# Compute Availability
availability = uptime / (uptime + downtime)

# Plotting
plt.figure(figsize=(12, 6))

plt.subplot(3, 1, 1)
plt.plot(t, uptime, label='Uptime', color='green')
plt.title('System Uptime')
plt.xlabel('Time')
plt.ylabel('Uptime')
plt.grid(True)

plt.subplot(3, 1, 2)
plt.plot(t, downtime, label='Downtime', color='red')
plt.title('System Downtime')
plt.xlabel('Time')
plt.ylabel('Downtime')
plt.grid(True)

plt.subplot(3, 1, 3)
plt.plot(t, availability, label='Availability', color='blue')
plt.title('System Availability')
plt.xlabel('Time')
plt.ylabel('Availability')
plt.grid(True)

plt.tight_layout()
plt.show()

```

```


import psutil
import matplotlib.pyplot as plt
import time

# 設定
duration = 10  # 監視する時間（秒）
interval = 1   # サンプリング間隔（秒）

# メモリ使用量を記録するリスト
times = []
memories = []

# 開始時間
start_time = time.time()

# メモリ使用量を監視
while time.time() - start_time < duration:
    times.append(time.time() - start_time)
    memory_info = psutil.virtual_memory()
    memories.append(memory_info.percent)
    time.sleep(interval)

# プロット
plt.figure(figsize=(10, 5))
plt.plot(times, memories, label='Memory Usage (%)')
plt.xlabel('Time (s)')
plt.ylabel('Memory Usage (%)')
plt.title('Memory Usage Over Time')
plt.grid(True)
plt.legend()
plt.show()

```

```



```


```



```



```



```