New branch

1/1.py

@@ -0,0 +1,71 @@
+# 定義課程資料
+courses = [
+    {'teacher': '甲', 'name':'機率', 'hours': 2},
+    {'teacher': '甲', 'name':'線代', 'hours': 3},
+    {'teacher': '甲', 'name':'離散', 'hours': 3},
+    {'teacher': '乙', 'name':'視窗', 'hours': 3},
+    {'teacher': '乙', 'name':'科學', 'hours': 3},
+    {'teacher': '乙', 'name':'系統', 'hours': 3},
+    {'teacher': '乙', 'name':'計概', 'hours': 3},
+    {'teacher': '丙', 'name':'軟工', 'hours': 3},
+    {'teacher': '丙', 'name':'行動', 'hours': 3},
+    {'teacher': '丙', 'name':'網路', 'hours': 3},
+    {'teacher': '丁', 'name':'媒體', 'hours': 3},
+    {'teacher': '丁', 'name':'工數', 'hours': 3},
+    {'teacher': '丁', 'name':'動畫', 'hours': 3},
+    {'teacher': '丁', 'name':'電子', 'hours': 4},
+    {'teacher': '丁', 'name':'嵌入', 'hours': 3},
+    {'teacher': '戊', 'name':'網站', 'hours': 3},
+    {'teacher': '戊', 'name':'網頁', 'hours': 3},
+    {'teacher': '戊', 'name':'演算', 'hours': 3},
+    {'teacher': '戊', 'name':'結構', 'hours': 3},
+    {'teacher': '戊', 'name':'智慧', 'hours': 3}
+]
+
+teachers = ['甲', '乙', '丙', '丁', '戊']
+
+rooms = ['A', 'B']
+
+slots = [
+    'A11', 'A12', 'A13', 'A14', 'A15', 'A16', 'A17',
+    'A21', 'A22', 'A23', 'A24', 'A25', 'A26', 'A27',
+    'A31', 'A32', 'A33', 'A34', 'A35', 'A36', 'A37',
+    'A41', 'A42', 'A43', 'A44', 'A45', 'A46', 'A47',
+    'A51', 'A52', 'A53', 'A54', 'A55', 'A56', 'A57',
+    'B11', 'B12', 'B13', 'B14', 'B15', 'B16', 'B17',
+    'B21', 'B22', 'B23', 'B24', 'B25', 'B26', 'B27',
+    'B31', 'B32', 'B33', 'B34', 'B35', 'B36', 'B37',
+    'B41', 'B42', 'B43', 'B44', 'B45', 'B46', 'B47',
+    'B51', 'B52', 'B53', 'B54', 'B55', 'B56', 'B57'
+]
+
+# 初始化新的時間槽列表
+newSlots = [""] * len(slots)
+
+# 定義排課函數
+def schedule(target_hours, start_time, step=7):
+    i = 0
+    while i < len(courses):
+        if courses[i]["hours"] == target_hours:
+            for j in range(start_time, len(slots), step):
+                if newSlots[j:j+target_hours].count("") == target_hours:
+                    newSlots[j:j+target_hours] = [f'{courses[i]["name"]}({courses[i]["teacher"]})'] * target_hours
+                    courses.pop(i)
+                    i -= 1
+                    break
+        i += 1
+
+# 按照不同的授課時數進行排課
+schedule(4, 0)
+schedule(3, 1)
+schedule(3, 4)
+schedule(2, 2)
+schedule(2, 4)
+schedule(2, 0)
+for i in range(1, 7): schedule(1, i)
+schedule(1, 0)
+
+# 打印排課結果
+for i in range(len(newSlots)):
+    if i % 7 == 0: print()
+    print(slots[i] + ": " + (newSlots[i] if newSlots[i] else "Free"))

10/10.py

@@ -0,0 +1,53 @@
+# 參考chatgpt
+import openai
+import os
+import faiss
+import numpy as np
+from langchain.chains import RetrievalQA
+from langchain.embeddings.openai import OpenAIEmbeddings  # 修改引用路徑
+from langchain.llms import OpenAI
+
+
+
+# 示例文檔
+documents = [
+    "LangChain 是一個用於構建 LLM 驅動應用的框架。",
+    "RAG 是一種結合檢索和生成的技術，用於回答用戶問題。",
+    "ReAct 是一種基於檢索增強的推理策略。"
+]
+
+# 創建向量嵌入
+embeddings = OpenAIEmbeddings()
+document_embeddings = embeddings.embed_documents(documents)
+
+# 使用 FAISS 創建向量存儲
+dimension = len(document_embeddings[0])
+index = faiss.IndexFlatL2(dimension)
+index.add(np.array(document_embeddings))
+
+class FAISSVectorStore:
+    def __init__(self, index, documents):
+        self.index = index
+        self.documents = documents
+
+    def retrieve(self, query, k=5):
+        query_embedding = embeddings.embed_query(query)
+        D, I = self.index.search(np.array([query_embedding]), k)
+        return [self.documents[i] for i in I[0]]
+
+vector_store = FAISSVectorStore(index, documents)
+
+# 創建檢索增強的生成模型
+qa_chain = RetrievalQA(llm=OpenAI(), retriever=vector_store.retrieve)
+
+def main():
+    print("歡迎來到 RAG 系統！輸入 'exit' 以退出。")
+    while True:
+        user_input = input("你: ")
+        if user_input.lower() == 'exit':
+            break
+        response = qa_chain.run(input_text=user_input)
+        print(f"RAG: {response}")
+
+if __name__ == "__main__":
+    main()

11/__init__.py

@@ -0,0 +1 @@
+# 此期中作業完全來源於chatgpt

11/game.py

@@ -0,0 +1,53 @@
+class TicTacToe:
+    def __init__(self):
+        self.board = [' ' for _ in range(9)]  # 3x3 board
+        self.current_winner = None  # keep track of the winner!
+
+    def print_board(self):
+        # This is just getting the rows
+        for row in [self.board[i * 3:(i + 1) * 3] for i in range(3)]:
+            print('| ' + ' | '.join(row) + ' |')
+
+    @staticmethod
+    def print_board_nums():
+        # 0 | 1 | 2 etc (tells us what number corresponds to what box)
+        number_board = [[str(i) for i in range(j * 3, (j + 1) * 3)] for j in range(3)]
+        for row in number_board:
+            print('| ' + ' | '.join(row) + ' |')
+
+    def available_moves(self):
+        return [i for i, spot in enumerate(self.board) if spot == ' ']
+
+    def empty_squares(self):
+        return ' ' in self.board
+
+    def num_empty_squares(self):
+        return self.board.count(' ')
+
+    def make_move(self, square, letter):
+        # let's make the move
+        if self.board[square] == ' ':
+            self.board[square] = letter
+            if self.winner(square, letter):
+                self.current_winner = letter
+            return True
+        return False
+
+    def winner(self, square, letter):
+        # winner if 3 in a row anywhere.. we have to check all of these
+        row_ind = square // 3
+        row = self.board[row_ind * 3:(row_ind + 1) * 3]
+        if all([spot == letter for spot in row]):
+            return True
+        col_ind = square % 3
+        column = [self.board[col_ind + i * 3] for i in range(3)]
+        if all([spot == letter for spot in column]):
+            return True
+        if square % 2 == 0:
+            diagonal1 = [self.board[i] for i in [0, 4, 8]]
+            if all([spot == letter for spot in diagonal1]):
+                return True
+            diagonal2 = [self.board[i] for i in [2, 4, 6]]
+            if all([spot == letter for spot in diagonal2]):
+                return True
+        return False

11/main.py

@@ -0,0 +1,41 @@
+import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '.')))
+
+from game import TicTacToe
+from player import HumanPlayer, RandomComputerPlayer, GeniusComputerPlayer
+
+def play(game, x_player, o_player, print_game=True):
+    if print_game:
+        game.print_board_nums()
+
+    letter = 'X'
+    while game.empty_squares():
+        if game.num_empty_squares() == 0:
+            print("It's a tie!")
+            break
+        if letter == 'O':
+            square = o_player.get_move(game)
+        else:
+            square = x_player.get_move(game)
+
+        if game.make_move(square, letter):
+            if print_game:
+                print(letter + f' makes a move to square {square}')
+                game.print_board()
+                print('')
+
+            if game.current_winner:
+                if print_game:
+                    print(letter + ' wins!')
+                return letter
+            letter = 'O' if letter == 'X' else 'X'
+
+    if print_game:
+        print('It\'s a tie!')
+
+if __name__ == '__main__':
+    x_player = HumanPlayer('X')
+    o_player = GeniusComputerPlayer('O')
+    t = TicTacToe()
+    play(t, x_player, o_player, print_game=True)

11/player.py

@@ -0,0 +1,77 @@
+import math
+import random
+
+class Player:
+    def __init__(self, letter):
+        self.letter = letter
+
+    def get_move(self, game):
+        pass
+
+class RandomComputerPlayer(Player):
+    def __init__(self, letter):
+        super().__init__(letter)
+
+    def get_move(self, game):
+        square = random.choice(game.available_moves())
+        return square
+
+class HumanPlayer(Player):
+    def __init__(self, letter):
+        super().__init__(letter)
+
+    def get_move(self, game):
+        valid_square = False
+        val = None
+        while not valid_square:
+            square = input(self.letter + '\'s turn. Input move (0-8): ')
+            try:
+                val = int(square)
+                if val not in game.available_moves():
+                    raise ValueError
+                valid_square = True
+            except ValueError:
+                print('Invalid square. Try again.')
+        return val
+
+class GeniusComputerPlayer(Player):
+    def __init__(self, letter):
+        super().__init__(letter)
+
+    def get_move(self, game):
+        if len(game.available_moves()) == 9:
+            square = random.choice(game.available_moves())
+        else:
+            square = self.minimax(game, self.letter)['position']
+        return square
+
+    def minimax(self, state, player):
+        max_player = self.letter
+        other_player = 'O' if player == 'X' else 'X'
+
+        if state.current_winner == other_player:
+            return {'position': None, 'score': 1 * (state.num_empty_squares() + 1) if other_player == max_player else -1 * (state.num_empty_squares() + 1)}
+        elif not state.empty_squares():
+            return {'position': None, 'score': 0}
+
+        if player == max_player:
+            best = {'position': None, 'score': -math.inf}
+        else:
+            best = {'position': None, 'score': math.inf}
+
+        for possible_move in state.available_moves():
+            state.make_move(possible_move, player)
+            sim_score = self.minimax(state, other_player)
+
+            state.board[possible_move] = ' '
+            state.current_winner = None
+            sim_score['position'] = possible_move
+
+            if player == max_player:
+                if sim_score['score'] > best['score']:
+                    best = sim_score
+            else:
+                if sim_score['score'] < best['score']:
+                    best = sim_score
+
+        return best

2/2.py

@@ -0,0 +1,53 @@
+import random
+
+# 定義城市座標
+citys = [
+    (0, 3), (0, 0),
+    (0, 2), (0, 1),
+    (1, 0), (1, 3),
+    (2, 0), (2, 3),
+    (3, 0), (3, 3),
+    (3, 1), (3, 2)
+]
+
+# 初始化路徑，從0到城市數量-1
+l = len(citys)
+path = [i for i in range(l)]
+print("初始路徑:", path)
+
+# 計算兩個城市之間的距離
+def distance(p1, p2):
+    x1, y1 = p1
+    x2, y2 = p2
+    return ((x2 - x1)**2 + (y2 - y1)**2)**0.5
+
+# 計算給定路徑的總距離
+def pathLength(p):
+    dist = 0
+    plen = len(p)
+    for i in range(plen):
+        dist += distance(citys[p[i]], citys[p[(i + 1) % plen]])
+    return dist
+
+# 打印初始路徑長度
+print("初始路徑長度:", pathLength(path))
+
+# 爬山演算法來優化路徑
+def hill_climb(path):
+    current_length = pathLength(path)
+    for _ in range(10000):  # 設置迭代次數
+        # 隨機選擇兩個位置進行交換
+        i, j = random.sample(range(len(path)), 2)
+        new_path = path[:]
+        new_path[i], new_path[j] = new_path[j], new_path[i]
+        new_length = pathLength(new_path)
+        # 如果新路徑更短，則接受新路徑
+        if new_length < current_length:
+            path = new_path
+            current_length = new_length
+    return path
+
+# 使用爬山演算法優化路徑
+optimized_path = hill_climb(path)
+print("優化後的路徑:", optimized_path)
+print("優化後的路徑長度:", pathLength(optimized_path))

3/3.py

@@ -0,0 +1,28 @@
+# 複製gpt的
+import scipy.optimize as opt
+
+# 目標函數係數
+c = [-3, -2, -5]  # 因為 linprog 是最小化問題，所以我們要把目標函數的係數取反
+
+# 限制條件係數矩陣
+A = [[1, 1, 0],
+     [2, 0, 1],
+     [0, 1, 2]]
+
+# 限制條件的右側常數項
+b = [10, 9, 11]
+
+# 變數的非負限制
+x_bounds = (0, None)
+y_bounds = (0, None)
+z_bounds = (0, None)
+
+# 解線性規劃問題
+result = opt.linprog(c, A_ub=A, b_ub=b, bounds=[x_bounds, y_bounds, z_bounds], method='highs')
+
+# 輸出結果
+if result.success:
+    print(f"最優解: x = {result.x[0]:.2f}, y = {result.x[1]:.2f}, z = {result.x[2]:.2f}")
+    print(f"最大值: {-result.fun:.2f}")  # 記得將結果取反
+else:
+    print("無法找到最優解")