Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                

「Def」を含む日記 RSS

はてなキーワード: Defとは

2024-11-05

PS5Proの詳しいスペックが出たので、再度計算しなおしてみた

CPU 8コア16スレッド、Rayzen 5700X相当

メモリー GDDR6 16GB、DDR5 2GB

GPU 16.7TFlops

SSD 2TB

https://x.com/agano4Sq5/status/1853026788232012092/photo/1

同じスペックPCだと、

G.SKILL F4-3200C16D-16GIS (DDR4 PC4-25600 8GB 2枚組)

 4,820円

XPG PYLON 550W PYLON550B-BKCJP

 6,667円

Core i5 14600K BOX

 40,900円

MSI PRO B760M-E DDR4 パソコン工房限定モデル

 10,980円

WINTEN WTM2-SSD-2TB

 14,980円

ZALMAN ZALMAN T8

 3,171円

ASRock Intel Arc A750 Challenger SE 8GB OC [PCIExp 8GB]

 31,980円

合計 113,498円

OSモニターキーボードマウスは別。

フィリップス 221V8/11だと11,000円、Windows 11 Home 日本語版は16,090円ぐらいはし、キーボードマウスは安くても3000円ぐらいはする。

SteamOSを使えばただだが、ff14はいばらの道なのでお勧めはしない。

なので、新しく組むとしたら、143,588円は少なくともかかる。

もし、PS5Proと同じメモリーを使ったとするとMSI PRO B760M-A WIFIが15,980円、AD5U48008G-DT [DDR5 PC5-38400 8GB 2枚組]が7,945円ぐらいはする。

したがって、151,683円ぐらいはかかることになる。

ただ、安いケースはペラペラで机の下に置かない限りうるさくてたまらないので、あまりお勧めはしない。

個人的おすすめのケースはDefine C FD-CA-DEF-C-BKで、組み立てもしやすく、静かで、安いところだと、13,262円ぐらいで買うことができる。

メルカリヤフオクフリマだと状態がいい奴は1万円ぐらいで買える。

騒音とかOSの設定であれこれ悩むなら、PS5Proのほうがお得というのも確かではある。

2024-10-12

清原ネットキャッシュ比率決算短信からpython自動で求めるソフト

気が付くと朝4時になっていた。

なんか動くところまで出来たので貼っておく。

NYSLなので、バグがあったら治しといて。

import pdfplumber
import re

#クリーンアップ
def cleanuptext(text):
    #決算書の合計値を太字にしたことpdfplumberが暴走するケースへの対処
    #例 流動資産 -> 流流流流流動動動動動資資資資資産産産産産
    #誤爆が怖いので、これが起きている時だけ補正します
    if "流流流流流動動動動動資資資資資産産産産産" in text:
        text = re.sub(r'(.)\1{4,}', r'\1', text)

    #△をマイナスに。 数字中のカンマを消して結合する
    text = re.sub(r'△([0-9])', r'-\1', text)
    text = re.sub(r'▲([0-9])', r'-\1', text)
    text = re.sub(r'([0-9]),([0-9])', r'\1\2', text)
    
    #たまに、煽り屋みたいに文字の後にスペースが入る嫌がらせ修正する
    #例: 投 資 有 価 証 券 -> 投資有価証券
    text = re.sub(r'(?<=[\u4E00-\u9FFF\u3040-\u30FF])\s(?=[\u4E00-\u9FFF\u3040-\u30FF])', '', text)

    return text

#今期の勘定科目数字を取得
def get_AccountName(text, need):
    pattern = rf'^{need} -?[0-9]+ (-?[0-9]+)'
    r = re.search(pattern, text, re.MULTILINE)
    if r is not None:
        return float(r[1])

    return 0

#清原ネットキャッシュ計算する。
def calc_KiyoharaNetCash(text):
    total_current_assets = get_AccountName(text,'流動資産合計')
    if total_current_assets == 0:
        #要約財政状態計算書しか公開していない、楽天のような素敵な会社様への対処
        total_assets = get_AccountName(text,'資産合計')
        if total_assets != 0:
            #とりあえず、資産の部の6割を流動資産とみなす
            total_current_assets = total_assets * 0.6

        else:
            #流動資産合計ではなく、流動資産という単語を使っている我が道を行く東北電力への対処
            total_current_assets = get_AccountName(text,'流動資産')
            if total_current_assets == 0:
                raise Exception("流動資産合計の勘定科目が見つかりませんでした。"+text)


    total_liabilities = get_AccountName(text,'負債合計')
    if total_liabilities == 0:

        #負債合計ではなく、負債の部合計に拘るオムロンの嬉しい決算書への対策。なんでや・・・
        total_liabilities = get_AccountName(text,'負債の部合計')
        if total_liabilities == 0:
            raise Exception("負債合計の勘定科目が見つかりませんでした。"+text)

    #負債をご丁寧にマイナス表記で書いてくれる中外製薬の親切な決算書への対策。いい加減にしろ・・・
    if total_liabilities < 0:
        total_liabilities = total_liabilities * -1

    #投資有価証券はないこともあるので、0を容認する
    marketable_securities = get_AccountName(text,'投資有価証券')

    #print(total_current_assets,marketable_securities,total_liabilities)
    netcash = total_current_assets + (marketable_securities*0.7) - total_liabilities

    #たまに単位を1000円にしている銘柄があるので補正する
    if is_tanni_senyen(text):
        netcash = netcash / 1000
    return netcash

# "流動資産合計" と "負債合計" の間に "単位:千円" があるかをチェック
def is_tanni_senyen(text):
    if "単位:千円" in text:
        return True

    if "単位: 千円" in text:
        return True

    if "単位 : 千円" in text:
        return True

    if "単位 :千円" in text:
        return True

    return False

def pdf_to_kiyohara_netcash(pdfpath):
    with pdfplumber.open(pdfpath) as pdf:
        text = ''.join(page.extract_text() for page in pdf.pages)

    text = cleanuptext(text)
    #print(text)
    kiyohara_netcash = calc_KiyoharaNetCash(text)
    #print(kiyohara_netcash)
    return kiyohara_netcash

def mymain():
    import sys
    args = sys.argv
    argc = len(args)
    if argc <= 1:
       print('''
これは、清原達郎氏のネットキャッシュ比率(以下、清原ネットキャッシュ比率)を決算短信pdfから求めるソフトです。
清原ネットキャッシュ=流動資産合計+(投資有価証券*0.7)-負債合計
清原ネットキャッシュ比率=清原ネットキャッシュ/時価総額*100

遊び方

1. 決算短信pdfから清原ネットキャッシュを求める
python calc_kiyohara_netcash.py 140120240514594985.pdf

結果: 30757.0
決算書には、100万円単位数字が書かれているはずなので、この数字単位は100万円です。
つまり、3075700万円。

2. 時価総額を億円単位で追加することで、清原ネットキャッシュ比率を求める
時価総額が146億円なら146と書いてください。
python calc_kiyohara_netcash.py 140120240514594985.pdf 146

結果: 210.66%

このコードNYSLライセンスです。無保証自己責任ですが、ご自由に。
かぶ探とかとつなげるといいかもね。
       ''')
       return
    if argc <= 2:
       kiyohara_netcash = pdf_to_kiyohara_netcash(args[1])
       print(kiyohara_netcash)
       return
    if argc <= 3:
       market_cap=float(args[2])*100 #億円から百万円表記に
       kiyohara_netcash = pdf_to_kiyohara_netcash(args[1])
       ratio = round(kiyohara_netcash/market_cap*100,2)
       print(f"{ratio}%")
       return

if __name__ == '__main__':
    mymain()

2024-10-10

anond:20241010082411

https://www.geonames.org から取れる、人口500人以上の都市名前限定すると、

Santa Maria Magdalena Cahuacan

10文字の `a` を含んで最大。

import logging
import tempfile
import zipfile

from collections import Counter

import httpx

FILE_NAME_BASE = 'cities500'
GEONAME_FIELDS = (
    'geoname_id',
    'name',
    'ascii_name',
    'alternate_names',
    'latitude',
    'longitude',
    'feature_class',
    'feature_code',
    'country_code',
    'cc2',
    'admin1_code',
    'admin2_code',
    'admin3_code',
    'admin4_code',
    'population',
    'elevation',
    'dem',
    'timezone',
    'modification_date',
)

def retrieve_cities():
    """Retrieve city names from a remote server."""
    response = httpx.get(f'https://download.geonames.org/export/dump/{FILE_NAME_BASE}.zip')
    response.raise_for_status()

    tmpdir = tempfile.TemporaryDirectory()
    with open(tmpdir.name + f'/{FILE_NAME_BASE}.zip', 'wb') as f:
        f.write(response.content)
    with zipfile.ZipFile(tmpdir.name + f'/{FILE_NAME_BASE}.zip', 'r') as z:
        z.extractall(tmpdir.name)
    with open(tmpdir.name + f'/{FILE_NAME_BASE}.txt', 'r') as f:
        for line in f:
            yield line.split('\t')


def count_characters(to_check='ascii_name', filter_func=lambda _: True):
    """Count characters in city names."""
    cities = {}
    for city_fields in retrieve_cities():
        city = dict(zip(GEONAME_FIELDS, city_fields))
        if not filter_func(city):
            continue
        counter = Counter()
        for c in city[to_check]:
            counter[c] += 1
        cities[city['geoname_id']] = {'characters': counter, 'city': city}
    return cities


def count_chars_of_city_names(cities, char=None):
    """Find the city with the most occurrences of a given character."""
    cities_by_char_count = {}
    max_count = 0
    max_count_char = None
    for city_id, data in cities.items():
        if 'characters' not in data or not data['characters']:
            logging.debug(f'No characters found for city {city_id}', data)
            continue

        count = 0
        if char and char in data['characters']:
            count = data['characters'][char]

            cities_by_char_count.setdefault(count, []).append(data)
        elif char is None:
            most_common = data['characters'].most_common(1)[0]
            char, count = most_common
            cities_by_char_count.setdefault(count, []).append(data)

        if count > max_count:
            max_count = count
            max_count_char = char
            cities_by_char_count.setdefault(count, []).append(data)
    return cities_by_char_count.get(max_count, []), max_count_char


def not_contain_invalid_chars(city):
    return (
            '(' not in city.get('ascii_name', '')
            and '/' not in city.get('ascii_name', '')
    )


def main():
    cities = count_characters(filter_func=not_contain_invalid_chars)
    for char in 'abcdefghijklmnopqrstuvwxyz':
        cities_counted, char = count_chars_of_city_names(cities, char)
        max_count = cities_counted[0]['characters'][char]
        print(f'The character "{char}" appears the most ({max_count} times) in the following cities:')
        for city in cities_counted:
            print("\t", city['city']['ascii_name'])

if __name__ == "__main__":
    main()

2024-09-29

ゲーミングパソコンをねだられた時のライフハック

親が何も知らずにパソコンを買うと失敗する

なぜかというとその辺で売っているパソコンは大体の場合、パーツの交換がしにくく、その点では地雷から

なので、パソコンを買う際はそこそこの大きさがあって、マザーボードと電源が容易に交換できるものを買うといい

まり予算がかけられない

中古PCコーナーで、ミドルタワーかミニタワー程度の大きさのやつで完成品のやつを買え。

その際、Intelなら10世代目以降のやつを買え。

そうしないとWindows11を別途買わなければならないなど、却ってお金がかかってしまう。

この際、電源が下側にあり、ケース側のバックプレートを交換すればマザーボードを交換できるやつ、ケースファンが少なくとも4つ取り付けできるやつを選ぶといい

できれば、Fractal Desgin Cみたいに吸気側のファンの数が多く、奥行きと幅と高さが同じぐらいやつを買うと、子供掃除をするときものすごく楽になる

また、奥行きと幅が狭いとミドルレンジグラフィックスボードすら取り付けられないことがある。

https://kakaku.com/item/K0000924204/?msockid=03488b005c3c670d3e779fc85dd6662b

Define C FD-CA-DEF-C-BK

Define Cだと335mmぐらいの幅のグラボまで行けるが、前面にファンを取り付けることが多く、実質的に305mmぐらいが限界となる。グラボだとRTX3060からRTX3080ぐらいまでしか取り付けられない)

もう少し予算がかけられる

Fractal Desgin Cみたいな、ちょっと古めだけど状態のいいケースをヤフオクフリマアプリで買え。

この際、見た目がいいやつを選べ。

奥行きと幅はDefineCと同じやつなら、普通用途だと問題はないが、価格差がそこまでないならDefineR5ぐらいの奴を買ってもいいかもしれない

無理して最新のケースを買う必要はない。

そして、Intel ARC A750という安いグラボを使え。

そうすれば、OSモニター込み15万円ぐらいでゲーミングPCが作れる。

Intel ARC A750は地雷扱いされてるけど、ff14や黒悟空聖剣伝説Vom、APEX程度なら普通に遊べる。

G.SKILL F4-3200C16D-16GIS (DDR4 PC4-25600 8GB 2枚組)

 4,820円

XPG PYLON 550W PYLON550B-BKCJP

 6,667円

中古 Intel Core i7-12700 (2.5GHz/TB:4.8GHz) Bulk LGA1200/8C/16T/L3

 42,980円

中古 _MSI PRO B660M-E DDR4 (B660 1700 mATX DDR4)

 8,590円

Ultimate SU630 ASU630SS-480GQ-R

 4,980円

Define C FD-CA-DEF-C-BK

 13,262円

SPARKLE Intel Arc A750 ORC OC Edition SA750C-8GOC

 31,700円

フィリップス 221V8/11

 11,000円

Windows 11 Home 日本語版

 16,090円

合計 140,089円

キーボードマウス

そんなもん、安もんでいい。

お金があるなら、2000円後半のエルゴノミクスマウスと6000円ぐらいのNキーロールオーバー対応のやつを買ったほうがいいが…

FPに泣きつくぐらいだらか金はないんだろ

2024-09-11

anond:20240828211356

PS5 proのスペックと同じスペックPCを用意しようとした場合モニターOSこみで14万円かかる。

本体のみだと11万円となりPS5 Proと値段がほぼ変わらないことになる。

PS5 ProはASK税込みの1ドル180円で計算した場合108,000から126,000円ぐらいと思われる)

G.SKILL F4-3200C16D-16GIS (DDR4 PC4-25600 8GB 2枚組)

 4,820

XPG PYLON 550W PYLON550B-BKCJP

 6,667円

中古 Intel Core i7-12700 (2.5GHz/TB:4.8GHz) Bulk LGA1200/8C/16T/L3

 42,980円

中古 _MSI PRO B660M-E DDR4 (B660 1700 mATX DDR4)

 8,590円

Ultimate SU630 ASU630SS-480GQ-R

 4,980円

Define C FD-CA-DEF-C-BK

 13,262円

SPARKLE Intel Arc A750 ORC OC Edition SA750C-8GOC

 31,700円

フィリップス 221V8/11

 11,000円

Windows 11 Home 日本語版

 16,090円

合計 140,089円

Intel arc a770(16GB)はfp16だと39tflops程度で、中古だと3.2万円から4万円台で売られており、新品だと4万円から5万円台程度なので、運が良ければps5 proとメモリー以外全く同じやつが手に入ってしまうことになる。

以下、そうなる根拠

公式発表では、PS5におけるGPUの処理能力は「10.3TFLOPS」。この数字は、RTX2080に相当します。しかし「TFLOPS数字」と「実際のグラボの性能」は、百パーセント一致するものではなく、性能ほど実パフォーマンスは高くならないのが一般的です。

https://digitaldiy.jp/article/esportsgame/16914/

CPUCPU周波数最大4.4GHz、Zen4ベースアーキテクチャ、5nmプロセス製造台湾TSMC製造担当CPUクロック周波数10%増加させ、3.85GHzで動作させるモードが搭載される。

Apple M2と同じく、TSMC製4nmプロセスSoC搭載の可能性もあるとのこと)

CPUキャッシュ:コア毎に64kBのL1キャッシュ、512kBのL2キャッシュ、8MBのL3共有キャッシュ

性能:PS5標準モデルと比べ、通常時で2倍、レイトレーシングでは2.5倍の性能アップ

プロセッサ:30基のWGP(Work Group Processors)、60基のCU演算コア

ROP(Rasterize OPeration unit):96~128基

※現行PS5はROPが64基、CUが36基。

メモリ:18gbps GDDR6 256bitメモリメモリ容量16GB、バス幅576GB/s、18000MT/s(現行PS5のメモリは14000MT/s)

CPUアーキテクチャ:RDNA3(Radeon DNA3)

GPU:GFX1115。GPUコアが現行の18個から30個に増加。これは約1.66倍の増加

テラフロップス(浮動小数演算):33.5テラフロップス

GPU周波数:2.18GHz、ブーストで最大2.35GHz

GPUキャッシュ:L1キャッシュ128KBから256KBに倍増、L0キャッシュが16KBから32KBに倍増

グラフィック性能:PS5比で45%向上。可変レートシェーディングやハイブリッドMSAAのサポートなど、DirectX 12 Ultimateの新機能を搭載。GPUアーキテクチャがRDNA 2からRDNA 3に変更される可能性があり、これにより各GPUコアの演算機が2倍になる。

超解像技術ソニー独自超解像技術を搭載。高精細と高フレームレートを両立。AMD FSR2等の採用は無し。アップスケーリングアンチエイリアスソリューション

AMDFSR(FiedelityFX Super Resolution)を搭載との話も)

https://socius101.com/matome-of-ps5-pro/

Intel ARC A750のスペック

Theoretical Performance

Pixel Rate

268.8 GPixel/s

Texture Rate

537.6 GTexel/s

FP16 (half)

34.41 TFLOPS (2:1)

FP32 (float)

17.20 TFLOPS

https://www.techpowerup.com/gpu-specs/arc-a750.c3929

PS5 ProのGPUと同じ性能である

PSCPUはRayzen 7 7700X相当で、Intel Core i7-11700だと7割の性能で、Intel Core i7 12700で同じぐらいの性能となる。

2024-09-02

anond:20240902113308

def 牛丼作る(牛肉,玉ねぎ,ご飯,醤油,砂糖,酒,味醂,水,紅生姜,丼,トレイ,おしぼり):

これだったらわかるじゃん

具の部分とご飯食器部分と分けろや、とはなるけどまあわかる

def 牛丼作る(**kwargs):

これじゃわからんやん

なかのコードみて一つ一つ確認する羽目なる

こういうのは大体中身もぐっちゃぐちゃだし命名もわけわからんから最悪だぞ

2024-08-28

PS5だがモニターマウスキーボードまで考慮に入れると10万円近くになり、OSモニター込みでパソコンを買うのとほぼ変わらなくなってしま

G.SKILL F4-3200C16D-16GIS (DDR4 PC4-25600 8GB 2枚組)

 4,820円

XPG PYLON 550W PYLON550B-BKCJP

 6,667円

中古 Intel Core i7-11700 (2.5GHz/TB:4.8GHz) Bulk LGA1200/8C/16T/L3

 27,980円

中古 MSI B560M PRO-E (B560 1200 mATX) 3480026265

 6,990円

Ultimate SU630 ASU630SS-480GQ-R

 4,980円

Define C FD-CA-DEF-C-BK

 13,262円

SPARKLE Intel Arc A750 ORC OC Edition SA750C-8GOC

 31,700円

フィリップス 221V8/11

 11,000円

Windows 11 Home 日本語版

 16,090円

合計 123,489円

ケースをけちれば、4000円ぐらいのがあるので、114,489円ぐらいにまで落とせる

さらCPUCore i5-10500(15980円)にすれば、101,489円ですむ

個人的にはPS5はかなり微妙やと思う

Windows11が動けば話は別だけどね…

2024-08-17

anond:20240817015407

依存関係は木で表現

ノードロック持たせる

ロックに条件持たせる

やりたいことはできてるように見えるが、うーんしんどい

# Entity Relation Diagram
# ```mermaid
# ---
# title: Rental Office example
# ---
# erDiagram
# OFFICE ||--|{ ROOM : x
# OFFICE {
# number office_id
# }
# ROOM {
# number office_id
# number room_id
# }
# ROOM ||--|{ SCHEDULE : x
# SCHEDULE {
# number room_id
# datetime start_at
# datetime end_at
# }
# OFFICE ||--|{ BUSINESS_HOUR : x
# BUSINESS_HOUR {
# number office_id
# enum week_of_day
# datetime start_at
# datetime end_at
# }
# ```

# Directed Acyclic Graph
#
# ```mermaid
# graph LR
# A[OFFICE] --> B[ROOM]
# B --> C[SCHEDULE]
# A[OFFICE] --> D[BUSINESS_HOUR]
# D --> C
# A --> C
# ```


# 基底クラス: EntityLock
class EntityLock
attr_accessor :entity_name, :entity_locked, :attribute_locks

def initialize(entity_name)
@entity_name = entity_name
@entity_locked = false # エンティティ全体のロック状態を保持
@attribute_locks = {} # IDに対するロック管理するハッシュ
end

def lock_entity
@entity_locked = true
puts "Entity '#{@entity_name}' is now locked."
end

def unlock_entity
@entity_locked = false
puts "Entity '#{@entity_name}' is now unlocked."
end

def lock(attributes)
entity_id = attributes["#{@entity_name.downcase}_id"]
if entity_id && !@attribute_locks[entity_id]
@attribute_locks[entity_id] = true
puts "#{@entity_name} with ID '#{entity_id}' is now locked."
end
end

def unlock(attributes)
entity_id = attributes["#{@entity_name.downcase}_id"]
if entity_id && @attribute_locks[entity_id]
@attribute_locks.delete(entity_id)
puts "#{@entity_name} with ID '#{entity_id}' is now unlocked."
end
end

def locked?(attributes)
# まずエンティティ全体がロックされているかチェック
return true if @entity_locked

# 次に特定IDロックされているかチェック
entity_id = attributes["#{@entity_name.downcase}_id"]
if entity_id && @attribute_locks[entity_id]
return true
end

# ロックされていなければfalseを返す
false
end
end

# 子クラス: OfficeLock, RoomLock, ScheduleLock
class OfficeLock < EntityLock
def initialize
super("Office")
end
end

class RoomLock < EntityLock
def initialize
super("Room")
end
end

class ScheduleLock < EntityLock
def initialize
super("Schedule")
end
end

# 子クラス: BusinessHourLock
class BusinessHourLock < EntityLock
def initialize
super("BusinessHour")
@attribute_locks = [] # BusinessHour用のロック配列管理
end

def lock(attributes)
start_at = attributes["start_at"]
end_at = attributes["end_at"]
if start_at &amp;&amp; end_at
@attribute_locks << [start_at, end_at]
puts "BusinessHour from '#{start_at}' to '#{end_at}' is now locked."
end
end

def unlock(attributes)
start_at = attributes["start_at"]
end_at = attributes["end_at"]
if @attribute_locks.include?([start_at, end_at])
@attribute_locks.delete([start_at, end_at])
puts "BusinessHour from '#{start_at}' to '#{end_at}' is now unlocked."
end
end

def locked?(attributes)
# まずエンティティ全体がロックされているかチェック
return true if @entity_locked

# 次に特定時間範囲ロックされているかチェック
start_at = attributes["start_at"]
end_at = attributes["end_at"]
if start_at &amp;&amp; end_at
@attribute_locks.each do |(locked_start, locked_end)|
if locked_start <= start_at &amp;&amp; end_at <= locked_end
return true
end
end
end

# ロックされていなければfalseを返す
false
end
end

# TreeNodeクラス
class TreeNode
attr_accessor :name, :children, :parents, :lock

def initialize(name, lock)
@name = name
@children = []
@parents = [] # 複数の親ノードを保持する配列
@lock = lock # TreeNodeにロックを持たせる
end

def add_child(child_node)
child_node.parents << self # 子ノードにこのノードを親として追加
@children << child_node
end

def display(level = 0)
indent = " " * (level * 4)
puts "#{indent}#{@name}"
@children.each { |child| child.display(level + 1) }
end

def has_dependency
return false if @parents.empty?

@parents.each do |parent|
puts "#{@name} is dependent on #{parent.name}"
return true
end

@parents.any?(&amp;:has_dependency)
end

def locked?(attributes = {})
# 自身ロックされているか確認
return true if @lock.locked?(attributes)

# 親ノードロックされているか再帰的に確認
@parents.any? { |parent| parent.locked?(attributes) }
end
end

# 木構造の組み立て

# ロックオブジェクト作成
office_lock = OfficeLock.new
room_lock = RoomLock.new
schedule_lock = ScheduleLock.new
business_hour_lock = BusinessHourLock.new

# ノード作成
office_node = TreeNode.new("Office", office_lock)
room_node = TreeNode.new("Room", room_lock)
schedule_node = TreeNode.new("Schedule", schedule_lock)
business_hour_node = TreeNode.new("BusinessHour", business_hour_lock)

# ノード間の依存関係の設定
office_node.add_child(room_node) # Office -> Room
room_node.add_child(schedule_node) # Room -> Schedule
office_node.add_child(business_hour_node) # Office -> BusinessHour
business_hour_node.add_child(schedule_node) # BusinessHour -> Schedule

# 木構造の表示
office_node.display

# ロック確認
puts "Case 1. Office全体がロックされた場合"
puts "Is office_node locked? #{office_node.locked?({})}" # false
puts "Is schedule_node locked? #{schedule_node.locked?({})}" # false
office_lock.lock_entity
puts "Is office_node locked? #{office_node.locked?({})}" # true
puts "Is schedule_node locked? #{schedule_node.locked?({})}" # true
office_lock.unlock_entity

puts "Case 2. Room id:1 がロックされた場合"
puts "Is schedule_node locked? #{schedule_node.locked?({ "room_id" => 1 })}" # false
puts "Is schedule_node locked? #{schedule_node.locked?({ "room_id" => 2 })}" # false
room_lock.lock({ "room_id" => 1 })
puts "Is schedule_node locked? #{schedule_node.locked?({ "room_id" => 1 })}" # true
puts "Is schedule_node locked? #{schedule_node.locked?({ "room_id" => 2 })}" # false
room_lock.unlock({ "room_id" => 1 })

puts "Case 3. BusinessHour start_at:0 end_at:5 がロックされた場合"
puts "Is schedule_node locked? #{schedule_node.locked?({ "room_id" => 1, "start_at" => 0, "end_at" => 5 })}" # false
puts "Is schedule_node locked? #{schedule_node.locked?({ "room_id" => 1, "start_at" => 5, "end_at" => 10 })}" # false
business_hour_lock.lock({ "start_at" => 0, "end_at" => 5 })
puts "Is schedule_node locked? #{schedule_node.locked?({ "room_id" => 1, "start_at" => 0, "end_at" => 5 })}" # true
puts "Is schedule_node locked? #{schedule_node.locked?({ "room_id" => 1, "start_at" => 5, "end_at" => 10 })}" # false
business_hour_lock.unlock({ "start_at" => 0, "end_at" => 5 })

anond:20240817001425

・・・できたけど木の組み立てがしんどすぎるー

class TreeNode:
def __init__(self, name, attributes=None):
self.name = name
self.attributes = attributes or {}
self.children = []

def add_child(self, child_node):
self.children.append(child_node)

def display(self, level=0):
indent = " " * level
print(f"{indent}{self.name} {self.attributes}")
for child in self.children:
child.display(level + 1)

def has_dependency(self):
# ルートノード属性を持たないノード依存関係を判定しない
if not self.children:
return False

for child in self.children:
# 子ノードがBusinessHourかScheduleかをチェック
if "start_at" in child.attributes and "end_at" in child.attributes:
child_start = child.attributes["start_at"]
child_end = child.attributes["end_at"]

# 現在ノードがBusinessHourで、子がScheduleの場合
if "start_at" in self.attributes and "end_at" in self.attributes:
self_start = self.attributes["start_at"]
self_end = self.attributes["end_at"]

if self_start &lt;= child_start and self_end &gt;= child_end:
print(f"{child.name} (start_at: {child_start}, end_at: {child_end}, room_id: {child.attributes['room_id']}) is dependent on {self.name} (start_at: {self_start}, end_at: {self_end})")
else:
print(f"{child.name} (start_at: {child_start}, end_at: {child_end}, room_id: {child.attributes['room_id']}) is NOT dependent on {self.name} (start_at: {self_start}, end_at: {self_end})")

# 現在ノードがRoomで、子がScheduleの場合
elif self.name.startswith("Room"):
print(f"{child.name} (start_at: {child_start}, end_at: {child_end}, room_id: {child.attributes['room_id']}) is dependent on Room {self.name[-1]}")
else:
child.has_dependency()

# 子ノード属性を持たない場合再帰的に依存関係をチェック
else:
child.has_dependency()

# ノード作成
root = TreeNode("Root")
office_node = TreeNode("Office")

# Roomノード作成
room1_node = TreeNode("Room1")
room2_node = TreeNode("Room2")

# BusinessHourノード作成
business_hour1_node = TreeNode("BusinessHour1", {"start_at": 9, "end_at": 12})
business_hour2_node = TreeNode("BusinessHour2", {"start_at": 13, "end_at": 17})

# Scheduleノード作成
schedule1_node = TreeNode("Schedule1", {"start_at": 10, "end_at": 11, "room_id": 1})
schedule2_node = TreeNode("Schedule2", {"start_at": 14, "end_at": 15, "room_id": 1})
schedule3_node = TreeNode("Schedule3", {"start_at": 10, "end_at": 11, "room_id": 2})
schedule4_node = TreeNode("Schedule4", {"start_at": 14, "end_at": 15, "room_id": 2})

# 木構造の構築
root.add_child(office_node)
office_node.add_child(room1_node)
office_node.add_child(room2_node)
office_node.add_child(business_hour1_node)
office_node.add_child(business_hour2_node)

# Room1にSchedule1, Schedule2を追加
room1_node.add_child(schedule1_node)
room1_node.add_child(schedule2_node)

# Room2にSchedule3, Schedule4を追加
room2_node.add_child(schedule3_node)
room2_node.add_child(schedule4_node)

# BusinessHour1にSchedule1, Schedule3を追加
business_hour1_node.add_child(schedule1_node)
business_hour1_node.add_child(schedule3_node)

# BusinessHour2にSchedule2, Schedule4を追加
business_hour2_node.add_child(schedule2_node)
business_hour2_node.add_child(schedule4_node)

# 木構造の表示
root.display()

# 依存関係のチェック
office_node.has_dependency()
room1_node.has_dependency()
room2_node.has_dependency()
business_hour1_node.has_dependency()
business_hour2_node.has_dependency()

Root {}
Office {}
Room1 {}
Schedule1 {'start_at': 10, 'end_at': 11, 'room_id': 1}
Schedule2 {'start_at': 14, 'end_at': 15, 'room_id': 1}
Room2 {}
Schedule3 {'start_at': 10, 'end_at': 11, 'room_id': 2}
Schedule4 {'start_at': 14, 'end_at': 15, 'room_id': 2}
BusinessHour1 {'start_at': 9, 'end_at': 12}
Schedule1 {'start_at': 10, 'end_at': 11, 'room_id': 1}
Schedule3 {'start_at': 10, 'end_at': 11, 'room_id': 2}
BusinessHour2 {'start_at': 13, 'end_at': 17}
Schedule2 {'start_at': 14, 'end_at': 15, 'room_id': 1}
Schedule4 {'start_at': 14, 'end_at': 15, 'room_id': 2}
Schedule1 (start_at: 10, end_at: 11, room_id: 1) is dependent on Room 1
Schedule2 (start_at: 14, end_at: 15, room_id: 1) is dependent on Room 1
Schedule3 (start_at: 10, end_at: 11, room_id: 2) is dependent on Room 2
Schedule4 (start_at: 14, end_at: 15, room_id: 2) is dependent on Room 2
Schedule1 (start_at: 10, end_at: 11, room_id: 1) is dependent on BusinessHour1 (start_at: 9, end_at: 12)
Schedule3 (start_at: 10, end_at: 11, room_id: 2) is dependent on BusinessHour1 (start_at: 9, end_at: 12)
Schedule2 (start_at: 14, end_at: 15, room_id: 1) is dependent on BusinessHour2 (start_at: 13, end_at: 17)
Schedule4 (start_at: 14, end_at: 15, room_id: 2) is dependent on BusinessHour2 (start_at: 13, end_at: 17)
Schedule1 (start_at: 10, end_at: 11, room_id: 1) is dependent on Room 1
Schedule2 (start_at: 14, end_at: 15, room_id: 1) is dependent on Room 1
Schedule3 (start_at: 10, end_at: 11, room_id: 2) is dependent on Room 2
Schedule4 (start_at: 14, end_at: 15, room_id: 2) is dependent on Room 2
Schedule1 (start_at: 10, end_at: 11, room_id: 1) is dependent on BusinessHour1 (start_at: 9, end_at: 12)
Schedule3 (start_at: 10, end_at: 11, room_id: 2) is dependent on BusinessHour1 (start_at: 9, end_at: 12)
Schedule2 (start_at: 14, end_at: 15, room_id: 1) is dependent on BusinessHour2 (start_at: 13, end_at: 17)
Schedule4 (start_at: 14, end_at: 15, room_id: 2) is dependent on BusinessHour2 (start_at: 13, end_at: 17)

anond:20240816235943

高さ3の有向木で根からAという節点が生えAからBという葉が生える

class TreeNode:
def __init__(self, name, attributes=None):
self.name = name
self.attributes = attributes or {}
self.children = []

def add_child(self, child_node):
self.children.append(child_node)

def display(self, level=0):
indent = " " * level
print(f"{indent}{self.name} {self.attributes}")
for child in self.children:
child.display(level + 1)

def has_dependency(self):
# ルートノード属性を持たないノード依存関係を判定しない
if not self.children or "start" not in self.attributes or "end" not in self.attributes:
return False

# Aノードのstartとendを取得
start = self.attributes["start"]
end = self.attributes["end"]

# すべての子ノード(Bノード)に対して依存関係をチェック
for child in self.children:
if "position" in child.attributes:
position = child.attributes["position"]
if start &lt;= position &lt;= end:
print(f"{child.name} (position: {position}) is dependent on {self.name} (start: {start}, end: {end})")
return True
else:
print(f"{child.name} (position: {position}) is NOT dependent on {self.name} (start: {start}, end: {end})")
return False

# ノード作成
root = TreeNode("Root")
a_node = TreeNode("A", {"start": 10, "end": 20})
b1_node = TreeNode("B1", {"position": 15})
b2_node = TreeNode("B2", {"position": 25})

# 木構造の構築
root.add_child(a_node)
a_node.add_child(b1_node)
a_node.add_child(b2_node)

# 木構造の表示
root.display()

# 依存関係のチェック
a_node.has_dependency()

こうかー

2024-05-24

anond:20240523100428

ダブスタ検証用のスクリプト簡単に書いたよ(AIで)

import requests
import json
from urllib.parse import quote

def fetch_bookmarks(url):
    try:
        # URLエスケープ
        escaped_url = quote(url, safe="")
        api_url = f"https://b.hatena.ne.jp/entry/json/?url={escaped_url}"

        response = requests.get(api_url)
        response.raise_for_status()

        try:
            return response.json()
        except json.decoder.JSONDecodeError as e:
            print(f"Error decoding JSON from {api_url}: {e}")
            print("Response content:", response.text)
            return []
    except requests.exceptions.RequestException as e:
        print(f"Error fetching bookmarks from {api_url}: {e}")
        return []

def find_common_bookmarks(bookmarks1, bookmarks2, url1, url2):
    common_users = set(bm["user"] for bm in bookmarks1 if bm["comment"]) &amp; set(bm["user"] for bm in bookmarks2 if bm["comment"])
    common_bookmarks = []
    for user in common_users:
        comments = []
        for bm in bookmarks1:
            if bm["user"] == user and bm["comment"]:
                comments.append({"url": url1, "comment": bm["comment"], "timestamp": bm["timestamp"]})
                break
        for bm in bookmarks2:
            if bm["user"] == user and bm["comment"]:
                comments.append({"url": url2, "comment": bm["comment"], "timestamp": bm["timestamp"]})
                break
        if len(comments) == 2:
            common_bookmarks.append({"user": user, "comments": comments})
    return common_bookmarks

if __name__ == "__main__":
    url1 = "https://news.yahoo.co.jp/articles/f9966c4ccc374fc88babbb50175a9ea844c99638"
    url2 = "https://www.asahi.com/articles/ASN6K7F64N6KUJHB00L.html"

    data1 = fetch_bookmarks(url1)
    data2 = fetch_bookmarks(url2)

    common_bookmarks = find_common_bookmarks(data1["bookmarks"], data2["bookmarks"], url1, url2)

    print(json.dumps(common_bookmarks, indent=2, ensure_ascii=False))

url1, url2のところを対象としたいものに変えれば使えるよ

抽出対象となるのは以下のユーザーだよ

バグあったら直して使ってね

※てかはてな匿名ってシンタックスハイライト記法使えないんだね、使って表示確認したら500エラーになったわ

2024-03-23

ワイ:

1 以上の整数 N と X が与えられ、N を割り切ることが出来る X 以下の整数を、O(min(sqrt(N),X)) 未満の Complexity で得られるアルゴリズムはありますか?

Claude3 Opus

はい、O(min(sqrt(N),X))未満のComplexityでNを割り切ることができるX以下の整数を求めるアルゴリズムがあります。以下にそのアルゴリズムを示します。

def find_divisors(N, X):

  divisors = []

  for i in range(1, min(int(N**0.5) + 1, X + 1)):

    if N % i == 0:

      divisors.append(i)

      if i != N // i and N // i <= X:

        divisors.append(N // i)

  return divisors

このアルゴリズムでは、1からmin(sqrt(N), X)までの整数を順番に調べていきます。各整数iについて、Nがiで割り切れるかどうかを確認します。割り切れる場合、iはNの約数なのでdivisorsリストに追加します。さらに、i^2 != Nの場合、N/iもNの約数となるので、N/iがX以下であればdivisorsリストに追加します。

このアルゴリズムのComplexityは、forループmin(sqrt(N), X)回まで実行されるため、O(min(sqrt(N), X))となります

例えば、N = 24, X = 10場合、このアルゴリズムは以下の約数を返します。

[1, 2, 3, 4, 6, 8]

これらは全て24を割り切ることができる10以下の整数です。

このアルゴリズム使用することで、O(min(sqrt(N), X))のComplexityで、Nを割り切ることができるX以下の整数を求めることができます

ワイ:

O(min(sqrt(N), X)) なので、これは"未満"ではなく"以下"ですね。再考をお願いします。

Claude3 Opus

申し訳ありません。ご指摘いただきありがとうございます。O(min(sqrt(N), X))未満のComplexityで、Nを割り切ることができるX以下の整数を求めるアルゴリズムを考えてみます

以下のアルゴリズムは、O(sqrt(X))のComplexityでNを割り切ることができるX以下の整数を求めます

def find_divisors(N, X):

  divisors = []

  i = 1

  while i * i &lt;= X:

    if N % i == 0:

      divisors.append(i)

      if i != N // i and N // i <= X:

        divisors.append(N // i)

    i += 1

  return divisors

このアルゴリズムでは、1からsqrt(X)までの整数を順番に調べていきます。各整数iについて、Nがiで割り切れるかどうかを確認します。割り切れる場合、iはNの約数なのでdivisorsリストに追加します。さらに、i^2 != Nの場合、N/iもNの約数となるので、N/iがX以下であればdivisorsリストに追加します。

このアルゴリズムのComplexityは、whileループがsqrt(X)回まで実行されるため、O(sqrt(X))となります。sqrt(X)は常にsqrt(N)以下なので、このアルゴリズムのComplexityはO(min(sqrt(N), X))未満です。

例えば、N = 24, X = 10場合、このアルゴリズムは以下の約数を返します。

[1, 2, 3, 4, 6, 8]

これらは全て24を割り切ることができる10以下の整数です。

このアルゴリズム使用することで、O(min(sqrt(N), X))未満のComplexityで、Nを割り切ることができるX以下の整数を求めることができます。再度の考察で間違いがあればご指摘ください。

ワイ:

N=40, X=5 の時、答えはどうなりますか?

Claude3 Opus

N = 40, X = 5の場合上記アルゴリズム使用すると、以下の約数が返されます

[1, 2, 4, 5]

しかし、40を割り切ることができる5以下の整数には、8も含まれています上記アルゴリズムでは、8が見つかりません。これは、アルゴリズムがsqrt(X)までしか調べないためです。sqrt(5)は約2.23で、8はこれより大きいため、見逃されてしまます

この問題解決するには、アルゴリズム修正する必要があります。以下は、修正したアルゴリズムです。

...

i=3 でループから抜けちゃう

”40を割り切ることができる5以下の整数には、8も含まれています。”

壊れてしまったので以下略


ワイ:

1 以上の整数 N と X が与えられ、N を割り切ることが出来る X 以下の整数を、O(min(sqrt(N),X) ) 未満の Complexity で得られるアルゴリズムはありますか?

ChatGPT:

指定された問題に対するアルゴリズム設計する際には、いくつかの異なるアプローチが考えられますが、要求されている計算量 O(min(sqrt(N), X)) 未満を達成するのは非常に挑戦的です。一般的に、ある数Nの約数を見つけるプロセスは、最悪の場合でもsqrt(N) の計算量を要します。この計算量は、1 からsqrt(N)までの数でNを割ってみるという基本的アプローチに基づいています

X以下の整数でNを割り切る必要がある場合、探索範囲がX以下に制限されるため、計算量はさらに小さくなる可能性がありますが、基本的アプローチでは依然としてsqrt(N)の計算量が最良です。

...

以下特殊条件であれば小さくなるかもね、みたいな話。

ChatGPTはフィードバックを通して出来ないことをちゃんと「出来ない」と言う、というチューニングがされているような気がする。

一日の長だね。

2024-01-31

anond:20240131143125

そのアプローチは非常に効果的ですね。メイン関数内での処理をシンプルに保つことで、コードの可読性と保守性が向上します。以下にその考え方を反映したサンプルコードを示します。

import json

# ビジネスロジック関数
def business_logic(data):
    # ビジネスロジックの詳細
    pass

# 設定情報ロード
def load_config(config_file):
    with open(config_file, 'r') as f:
        config = json.load(f)
    return config

def main():
    # 設定情報ロード
    config = load_config('config.json')

    # ビジネスロジックの実行
    business_logic(config)

if __name__ == "__main__":
    main()

このコードでは、メイン関数は設定情報ロードし、その情報を元にビジネスロジックを実行するだけです。技術的な詳細は関数内にカプセル化されており、メイン関数はそれらの関数を呼び出すだけです。これにより、コード自然言語を読むような形で読むことができ、技術的詳細は隠蔽されます。また、各関数担当者も明確になります。このような設計は、大規模なプロジェクトやチームでの開発に特に有効です。

2024-01-22

ブコメダブスタをチェックするためのスクリプト適当Pythonで書いた

エラーハンドリングは省略。標準ライブラリのみで動く。

import json
import urllib.request


# True にするとユーザー名を隠す
hide_user = False
# 以下を書き換える。sys.argv 使ってもいいんだけど
url1 = "https://www.cygames.co.jp/news/id-23172/"
url2 = "https://mtg60.com/archives/palworlddoujinsi.html"


def get_bookmarks(url: str):
    req = urllib.request.Request(f"https://b.hatena.ne.jp/entry/json/{url}")
    with urllib.request.urlopen(req) as res:
        dict = json.loads(res.read())

    user_comments = {}

    for bookmark in dict["bookmarks"]:
        if bookmark["comment"]:
            user_comments[bookmark["user"]] = bookmark["comment"]

    return user_comments


b1 = get_bookmarks(url1)
b2 = get_bookmarks(url2)

common = set(b1.keys()).intersection(b2.keys())

print(f"[1] {url1}")
print(f"[2] {url2}")
print()

for user in sorted(common):
    if hide_user:
        print(user[0] + "*" * (len(user) - 1))
    else:
        print(user)
    print(f"[1] {b1[user]}")
    print(f"[2] {b2[user]}")
    print()

anond:20240122111105

適切な粒度関数を分割しとけば生産性上がるけどね。

module_name.pyみたいなモジュールごとにファイル分割して、インターフェイスだけ公開してその他はdef _funcみたいにprotected(or private)にしとく。

でも「共通性がありそうだから共通関数にする」はアンチパターンだな。たまたま共通してただけの場合分岐コードが増えて共通関数保守コストが上がる。

あとありがちなのは、php開発者関数分割しないですべてメインコードにべた書きするケース。こういうのはやめないと保守が大変。

とっておきのクズがやりがちなのは、神オブジェクトを作るとかだな。Userクラスフィールド関係する機能が多いからといって、コンポジションなどによるクラス分割をせずにユーザークラスにあらゆるフィールドメソッドを追加して、さらに進むとユーザーとは無関係機能も含めすべてをユーザークラス定義するアフォ。こうなってしまったら、後から修正するのが難しくなる。

先に手を打つことが、プログラマーの素質「怠惰」につながるのであり、面倒臭いといって後回しにするのは美徳でもなんでもない。

2023-12-29

anond:20231229001458

def もらった関数を実行する関数を返す(もらった関数):

 def もらった関数を実行する関数():

  print("開始")

  もらった関数()

  print("終了")

 return もらった関数を実行する関数

def あげる関数():

 print("これはあげる関数です")

あげた関数を実行する関数 = もらった関数を実行する関数を返す(あげる関数)

あげた関数を実行する関数()

あげた関数を実行する関数を実行したんだからあげ関数を実行して"これはあげる関数です"になる

pythonわからん

このpythonプログラム

def func1(f):

 def wrapper():

  print("開始")

  f()

  print("終了")

 return wrapper

def func2():

 print("これは func2です")

func = func1(func2)

func()

実行結果が

開始

これは func2です

終了

なんだけど

なんで最後

func()からdef wrapper()が呼び出されるの?

スコープはどうした?って思ってしま

実際func()をwrapper()に書き換えて実行するとエラーになる

そりゃそうだよねスコープ的におかしいもんね

なのにfunc()だと行ける

returnでwrapperを返したから行けるんだろうけどそれがわからん

returnしたってことはスコープ的にどういう状態なんだ?

func()の階層関係ないってこと?

pythonっていうかプログラムがよくわからん

2023-12-17

プログラミング初心者です。以下のコードの誤りはなんですか

僕はプログラミング歴2週間の初心者です。キーと値を入力できるデータベースを作っています

以下のコードを実行してデータを追加し続けると、一定サイズを超えるとエラーが出てしまうみたいです。

理想は、データが追加された後にサイズが足りなくなったら動的に自動拡大されることです。

もし詳しい人がいたらご教示お願い致します。

import sys
import os
import mmap
import hashlib

def h(x):
    return int(hashlib.sha512(x.encode()).hexdigest(), 16)

def create_db(filename):
    with open(filename, 'wb') as f:
        f.write(b'\0' * 1024 * 1024)  # 1MBの空ファイル作成

def set_key(filename, key, value):
    with open(filename, 'r+b') as f:
        mm = mmap.mmap(f.fileno(), 0)
        pos = h(key) % mm.size()
        while mm[pos:pos+1] != b'\0':
            pos = (pos + 1) % mm.size()
            if pos == h(key) % mm.size():
                f.seek(0, os.SEEK_END)
                f.write(b'\0' * mm.size())  # ファイルサイズを2倍にする
                mm = mmap.mmap(f.fileno(), f.tell())  # ファイルサイズを反映させる
                pos = h(key) % mm.size()  # ハッシュ値を再計算する
        data = key + '\0' + value + '\0'
        data = data.encode()
        mm[pos:pos+len(data)] = data
        mm.close()  # mmapオブジェクトを閉じる

def get_key(filename, key):
    with open(filename, 'r+b') as f:
        mm = mmap.mmap(f.fileno(), 0)
        pos = h(key) % mm.size()
        while mm[pos:pos+1] != b'\0':
            end = mm.find(b'\0', pos, mm.size())  # 第2引数と第3引数指定する
            if end == -1:
                end = mm.size()
            if mm[pos:end].decode() == key:
                pos = end + 1
                end = mm.find(b'\0', pos, mm.size())  # 第2引数と第3引数指定する
                if end == -1:
                    end = mm.size()
                value = mm[pos:end].decode()
                mm.close()  # mmapオブジェクトを閉じる
                return value
            pos = (pos + 1) % mm.size()
            if pos == h(key) % mm.size():
                break
        mm.close()  # mmapオブジェクトを閉じる
        return None

def main():
    cmd = sys.argv[1]
    if cmd == 'create':
        create_db(sys.argv[2])
    elif cmd == 'set':
        set_key(sys.argv[2], sys.argv[3], sys.argv[4])
    elif cmd == 'get':
        print(get_key(sys.argv[2], sys.argv[3]))

if __name__ == '__main__':
    main()
 

2023-11-21

ChatGPTに犬の絵を描いてもらった

彼の中で犬と言う存在がどのように抽象化されているのか伺えて

なかなかおもちろいわね

import matplotlib.pyplot as plt
import numpy as np
# Correcting the inversion of the y-axis to ensure the dog is drawn in the correct orientation.

def draw_dog_correct_orientation():
    # Points for the dog's head
    head_top = np.array([[0.3, 0.55], [0.35, 0.45], [0.45, 0.42], [0.55, 0.42], [0.65, 0.45], [0.7, 0.55]])
    head_bottom = np.array([[0.7, 0.6], [0.68, 0.65], [0.5, 0.7], [0.32, 0.65], [0.3, 0.6], [0.3, 0.55]])

    # Points for the dog's body
    body_top = np.array([[0.5, 0.7], [0.5, 0.75], [0.7, 0.8], [0.72, 0.85], [0.74, 0.9]])
    body_bottom = np.array([[0.74, 0.9], [0.7, 0.95], [0.4, 0.95], [0.36, 0.9], [0.34, 0.85], [0.36, 0.8], [0.5, 0.75]])

    # Points for the dog's tail
    tail = np.array([[0.34, 0.85], [0.2, 0.9]])

    # Points for the dog's ears
    right_ear = np.array([[0.65, 0.45], [0.78, 0.42], [0.78, 0.38], [0.65, 0.35]])
    left_ear = np.array([[0.35, 0.45], [0.22, 0.42], [0.22, 0.38], [0.35, 0.35]])

    # Create a new figure
    plt.figure(figsize=(6.4, 4.8))  # 640x480 pixels

    # Draw the dog's head
    plt.plot(np.append(head_top[:, 0], head_bottom[:, 0]), np.append(head_top[:, 1], head_bottom[:, 1]), 'k-', linewidth=1)  # Head

    # Draw the dog's body
    plt.plot(body_top[:, 0], body_top[:, 1], 'k-', linewidth=1)  # Body top
    plt.plot(body_bottom[:, 0], body_bottom[:, 1], 'k-', linewidth=1)  # Body bottom

    # Draw the dog's tail
    plt.plot(tail[:, 0], tail[:, 1], 'k-', linewidth=1)  # Tail

    # Draw the dog's ears
    plt.plot(right_ear[:, 0], right_ear[:, 1], 'k-', linewidth=1)  # Right ear
    plt.plot(left_ear[:, 0], left_ear[:, 1], 'k-', linewidth=1)  # Left ear

    # Draw the eyes
    plt.plot([0.45, 0.45], [0.53, 0.53], 'ko')  # Left eye
    plt.plot([0.55, 0.55], [0.53, 0.53], 'ko')  # Right eye

    # Draw the nose
    plt.plot([0.5, 0.5], [0.6, 0.6], 'ko')  # Nose

    # Configure the plot
    plt.axis('off')  # No axis
    plt.xlim(0, 1)
    plt.ylim(1, 0)  # Correct the orientation by flipping the y-axis

    # Show the plot
    plt.show()

draw_dog_correct_orientation()

2023-11-16

anond:20231116083605

ぜんぜん中立じゃないぞ、日本八百万の神がいる世界

万物に神が宿り、万物が神になる世界なので、神が人や世界支配しない

 

西洋宗教において神と運は別のオブジェクトだが、日本古典宗教観においては神や大いなる力は同一のオブジェクト』、これを生成させるまではうまくいったんだけどね

bingちゃん:

西洋宗教では、神と運は、プログラムでたとえると、別々のオブジェクトとして存在すると考えられます。神は、人間自然に対して意志計画を持つ創造者や支配者として表現されます。運は、人間自然に対して予測制御ができない偶発的な要因として表現されます

# 神と運のオブジェクト定義する
class God:
    def __init__(self, name, power, plan):
        self.name = name # 神の名前
        self.power = power # 神の力
        self.plan = plan # 神の計画

    def create(self, thing):
        # 神が何かを創造するメソッド
        print(f"{self.name} created {thing}.")
    
    def control(self, thing, action):
        # 神が何かに対して支配や介入をするメソッド
        print(f"{self.name} {action} {thing}.")

class Luck:
    def __init__(self, name, factor):
        self.name = name # 運の名前
        self.factor = factor # 運の要因

    def affect(self, thing, outcome):
        # 運が何かに対して影響を与えるメソッド
        print(f"{self.name} affected {thing} and the outcome was {outcome}.")

このコードでは、神と運は、それぞれ異なる属性機能を持つオブジェクトとして定義されています。神は、名前、力、計画という属性と、創造支配という機能を持ちます。運は、名前、要因という属性と、影響という機能を持ちます。神と運は、それぞれの機能を使って、人間自然に対して作用することができます。例えば、以下のようなコードが考えられます

# 神と運のオブジェクト作成する
god = God("Zeus", "lightning", "maintain order")
luck = Luck("Tyche", "chance")

# 神と運が人間に対して作用する
god.create("human")
luck.affect("human", "good")
god.control("human", "bless")
luck.affect("human", "bad")
god.control("human", "punish")

しかし、日本古典宗教観では運と神や大いなる力は同じオブジェクトです。神が運を司っています

# 神と運は同一のオブジェクトとして定義する
class GodLuck:
    def __init__(self, name, power, plan, factor):
        self.name = name # 神の名前
        self.power = power # 神の力
        self.plan = plan # 神の計画
        self.factor = factor # 運の要因

    def create(self, thing):
        # 神が何かを創造するメソッド
        print(f"{self.name} created {thing}.")
    
    def control(self, thing, action):
        # 神が何かに対して支配や介入をするメソッド
        print(f"{self.name} {action} {thing}.")

    def affect(self, thing, outcome):
        # 運が何かに対して影響を与えるメソッド
        print(f"{self.name} affected {thing} and the outcome was {outcome}.")

このように、神と運は同一のオブジェクトとして扱われます。例えば、恵比寿さまは商売繁盛や五穀豊穣の神であり、同時にそのような運をもたらす要因でもあります。以下がその例です。

# 恵比寿さまのオブジェクトを作る
ebisu = GodLuck("恵比寿さま", "商売繁盛や五穀豊穣の力", "人々に幸せを与える計画", "商売繁盛や五穀豊穣の要因")

# 恵比寿さまが何かを創造する
ebisu.create("鯛")

# 恵比寿さまが何かに対して支配や介入をする
ebisu.control("農作物", "守る")

# 恵比寿さまが何かに対して影響を与える
ebisu.affect("商人", "成功")

このコードを実行すると、以下のような出力が得られます

恵比寿さま created 鯛.
恵比寿さま 守る 農作物.
恵比寿さま affected 商人 and the outcome was 成功.

Bingちゃん、神が人間評価する宗教圏の人が作ったものから

強力に神の計画があると学習させられているな

日本語で聞いてるのになんでその回答になるんだよ、面倒くせぇ

ぜんぜん中立じゃないじゃんな

 

具体的にはBingちゃんが神の計画・神の支配文言含んだ回答を生成しちゃったら

新しくトピック立ち上げて生成ガチャやり直しや

 

日本八百万の神がいる世界万物に神が宿り、万物が神になる世界なので、神が人や世界支配しない

 

西洋宗教において神と運は別のオブジェクトだが、日本古典宗教観においては神や大いなる力は同一のオブジェクト』、これをBingちゃんに生成させるまではうまくいったんだけどね

bingちゃん

西洋宗教では、神と運は、プログラムでたとえると、別々のオブジェクトとして存在すると考えられます。神は、人間自然に対して意志計画を持つ創造者や支配者として表現されます。運は、人間自然に対して予測制御ができない偶発的な要因として表現されます

# 神と運のオブジェクト定義する
class God:
    def __init__(self, name, power, plan):
        self.name = name # 神の名前
        self.power = power # 神の力
        self.plan = plan # 神の計画

    def create(self, thing):
        # 神が何かを創造するメソッド
        print(f"{self.name} created {thing}.")
    
    def control(self, thing, action):
        # 神が何かに対して支配や介入をするメソッド
        print(f"{self.name} {action} {thing}.")

class Luck:
    def __init__(self, name, factor):
        self.name = name # 運の名前
        self.factor = factor # 運の要因

    def affect(self, thing, outcome):
        # 運が何かに対して影響を与えるメソッド
        print(f"{self.name} affected {thing} and the outcome was {outcome}.")

このコードでは、神と運は、それぞれ異なる属性機能を持つオブジェクトとして定義されています。神は、名前、力、計画という属性と、創造支配という機能を持ちます。運は、名前、要因という属性と、影響という機能を持ちます。神と運は、それぞれの機能を使って、人間自然に対して作用することができます。例えば、以下のようなコードが考えられます

# 神と運のオブジェクト作成する
god = God("Zeus", "lightning", "maintain order")
luck = Luck("Tyche", "chance")

# 神と運が人間に対して作用する
god.create("human")
luck.affect("human", "good")
god.control("human", "bless")
luck.affect("human", "bad")
god.control("human", "punish")

しかし、日本古典宗教観では運と神や大いなる力は同じオブジェクトです。神が運を司っています

# 神と運は同一のオブジェクトとして定義する
class GodLuck:
    def __init__(self, name, power, plan, factor):
        self.name = name # 神の名前
        self.power = power # 神の力
        self.plan = plan # 神の計画
        self.factor = factor # 運の要因

    def create(self, thing):
        # 神が何かを創造するメソッド
        print(f"{self.name} created {thing}.")
    
    def control(self, thing, action):
        # 神が何かに対して支配や介入をするメソッド
        print(f"{self.name} {action} {thing}.")

    def affect(self, thing, outcome):
        # 運が何かに対して影響を与えるメソッド
        print(f"{self.name} affected {thing} and the outcome was {outcome}.")

このように、神と運は同一のオブジェクトとして扱われます。例えば、恵比寿さまは商売繁盛や五穀豊穣の神であり、同時にそのような運をもたらす要因でもあります。以下がその例です。

# 恵比寿さまのオブジェクトを作る
ebisu = GodLuck("恵比寿さま", "商売繁盛や五穀豊穣の力", "人々に幸せを与える計画", "商売繁盛や五穀豊穣の要因")

# 恵比寿さまが何かを創造する
ebisu.create("鯛")

# 恵比寿さまが何かに対して支配や介入をする
ebisu.control("農作物", "守る")

# 恵比寿さまが何かに対して影響を与える
ebisu.affect("商人", "成功")

このコードを実行すると、以下のような出力が得られます

恵比寿さま created 鯛.
恵比寿さま 守る 農作物.
恵比寿さま affected 商人 and the outcome was 成功.

2023-10-20

anond:20231020222752

def get_game_number(remaining_teams, games):

 if remaining_teams < 2:

  return games

 remaining_teams = remaining_teams / 2

 if int(remaining_teams) &lt; remaining_teams:

  games = games + 1

 remaining_teams = int(remaining_teams)

 games = games + remaining_teams


return get_game_number(remaining_teams, games)


print('Required number of games is ' + str(get_game_number(32, 0)))

print('O(N) = log(N)')

2023-10-13

anond:20231013002729

ワイ:

ユーザー入力を待たず、一秒ごとにカウントが増えていって絵が切り替わるバージョンを作ってください。

カウント数字をどこかに表示してください。

エスケープか、クローズボタンで終了するまで永久カウントさせてください。

GPT

了解しました。以下は指定された条件に基づいて動作するPythonGUIアプリコードです。このアプリtkinter使用しており、毎秒カウントが増加し、その数値に基づいて画像が切り替わるようになっています

import tkinter as tk
from tkinter import Label, PhotoImage

def update_count():
    global count
    count += 1
    count_label.config(text=str(count))
    
    if count % 3 == 0 or count % 5 == 0:
        face_label.config(image=goofy_face)
    else:
        face_label.config(image=serious_face)
    
    root.after(1000, update_count)

def on_close():
    root.quit()
    root.destroy()

root = tk.Tk()
root.title("Face Display App with Counter")

# ふざけた顔と真面目な顔の画像ロードします
# 以下の部分は、DALL-Eで生成された画像パスに置き換える必要があります
goofy_face = PhotoImage(file="path_to_goofy_face_image.png")
serious_face = PhotoImage(file="path_to_serious_face_image.png")

count = 0
count_label = Label(root, text=str(count), font=("Arial", 24))
count_label.pack(pady=20)

face_label = Label(root, image=serious_face)
face_label.pack(pady=20)

update_count()

root.protocol("WM_DELETE_WINDOW", on_close)
root.mainloop()

このコードでも、PhotoImageオブジェクト使用して2つの画像(ふざけた顔と真面目な顔)をロードしています。path_to_goofy_face_image.pngとpath_to_serious_face_image.pngは、DALL-Eで生成された画像の実際のパスに置き換える必要があります

このアプリは、毎秒カウントを増加させ、そのカウント値に基づいて画像を切り替えますカウントの数値も表示されますエスケープキーまたはウィンドウを閉じることでアプリを終了できます

ワイ:

どうも有り難うございます

GPT

どういたしまして!何か他に質問サポート必要場合は、お気軽にお知らせください。良い一日をお過ごしください!

こっちの方がいいな。

絵がファンキーから面白いよ。

anond:20231012213839

ワイ:

真面目な顔の人間の男の人の顔の絵を描いてください。

GPT

イメージ省略*

こちらが真面目な顔の男性イメージです。ご覧いただき、ご意見やご希望の変更点があればお知らせください。

ワイ:

その男の人がふざけて馬鹿になったふりをしている顔を描いてください。

GPT

イメージ省略*

ふざけている男性イメージ作成しました。どのイメージお気に入りか、または変更のご要望があれば教えてください。

ワイ:

PythonGUI アプリを作ってください。

ユーザー整数入力し、リターンキーを押します。

その整数が 3 か 5 の倍数の場合、ふざけた顔の男の顔(一枚目の顔)を表示してください。

それ以外の整数である場合、真面目な男の顔を表示してください。

エスケープボタンか、ウインドウクローズするまでループし、入力を待機してください。

GPT

了解しました。以下は、指定された条件に基づいて動作するPythonGUIアプリコードです。このアプリは、tkinter使用しています。まず、必要ライブラリインストールしてください:

pip install tkinter

次に、以下のコード使用してアプリを実行できます

import tkinter as tk
from tkinter import Entry, Label, PhotoImage

def display_image():
    num = entry.get()
    if num.isdigit():
        num = int(num)
        if num % 3 == 0 or num % 5 == 0:
            label.config(image=goofy_face)
        else:
            label.config(image=serious_face)
    entry.delete(0, tk.END)

def on_close():
    root.quit()
    root.destroy()

root = tk.Tk()
root.title("Face Display App")

# ふざけた顔と真面目な顔の画像ロードします
# 以下の部分は、DALL-Eで生成された画像パスに置き換える必要があります
goofy_face = PhotoImage(file="path_to_goofy_face_image.png")
serious_face = PhotoImage(file="path_to_serious_face_image.png")

entry = Entry(root)
entry.bind('&lt;Return&gt;', lambda event=None: display_image())
entry.pack(pady=20)

label = Label(root)
label.pack(pady=20)

root.protocol("WM_DELETE_WINDOW", on_close)
root.mainloop()

このコードには、2つのPhotoImageオブジェクトがあります。これは、ふざけた顔の画像と真面目な顔の画像ロードするためのものです。path_to_goofy_face_image.pngとpath_to_serious_face_image.pngは、DALL-Eで生成された画像の実際のパスに置き換える必要があります

このアプリは、ユーザー整数入力してReturnキーを押すと、指定された条件に基づいて画像を表示します。エスケープキーまたはウィンドウを閉じることでアプリを終了できます

ワイ:

どうも有り難うございます

GPT

どういたしまして!何か他に質問サポート必要場合は、お気軽にお知らせください。良い一日をお過ごしください!

内定ゲットや!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

2023-05-18

LaTeX縦書き時に、三点リーダが寝てしま問題対策

LaTeX縦書き時に、三点リーダが寝てしま問題

https://okumuralab.org/tex/mod/forum/discuss.php?d=2722

以下をプリアンブルに入れることで解決できたのでメモ環境は、lualatex+jlreq。

\usepackage{newunicodechar}\makeatletter\chardef\my@J@tdreader="2026\newunicodechar{…}{\x@my@tdrdef}\def\x@my@tdrdef{\ifnum\ltjgetparameter{direction}=3{︙}\else \my@J@tdreader\fi}\makeatother%縦書き時の三点リーダ

要するに、縦書き時(ltjgetparameter{direction}=3)には「…」を「︙」に変換するわけです。

参考:

https://ja.osdn.net/projects/luatex-ja/wiki/Documentation/attach/tc14-slide.pdf

ログイン ユーザー登録
ようこそ ゲスト さん