Quelques modèles de ma collection

Autre version du programme Syracuse

Pas	Touches
01	2
02	Kin ÷ 1		# n / 2
03	Kout 1
04	-
05	1
06	Kin + 3 	# TOF = TOF + 1
07	=
08	1/x		# Si n = 1 arrêt sur une erreur
09	Kout 1
10	-
11	RND		# Partie entière quand on est en FIX 0
12	+
13	.
14	5
15	=		# Si n est pair on obtient 1 et 0 sinon
16	x > 0		# Retour pas n°1 si n pair
17	6		# Sinon...
18	Kin × 1
19	1
20	Kin + 1		# 3n+1
21	Kout 1
22	x ≤ M		# Si n <= max retour au pas n°1
23	Min		# sinon mise à jour du max
24	x > 0		

Exemple d’utilisation pour N = 27 puis N = 17 :

MODE FIX 0
KAC
27 Min Kin 1 P1

Le programme s'arrête sur -E-
AC puis MR pour voir le maximum (9232) et Kout 3 pour le temps de vol (111)

Pour un autre calcul faire : 
KAC
17 Min Kin 1 P1
Résultats : max = 52 et TOF = 12

Décomposition d’un entier en facteurs premiers

Programme P1 :

001	Min
002	1
003	Kin 1
004	Mode 7 0    # Fix 0

Programme P2 :

001	MR
002	÷
003	1
004	Kin + 1
005	Kout 1
006	-
007	RND
008	=
009	x > 0
010	+/-
011	x > 0       # Cela revient à tester x ≠ 0
012	Kout 1
013	HLT
014	1/x
015	×
016	MR
017	=
018	Min
019	1
020	Kin - 1
021	Kout 1
022	x ≤ M
023	AC

Utilisation : Décomposition de 2024 en facteurs premiers

2024 P1
P2
Affichage : 2
RUN
Affichage : 2
RUN
Affichage : 2
RUN
Affichage : 11
RUN
Affichage : 23
RUN
0

Donc 2024 = 2 × 2 × 2 × 11 × 23

Lorsque le nombre est premier :

13 P1
P2
Affichage : 13
RUN
0

Conflit de ressources

import threading
import time

# Nombre de tickets disponibles (ressource partagée)
nb_tickets  = 10

def achat_ticket():
  global nb_tickets 
  if nb_tickets  > 0:
    # Simuler une lecture de la base de données
    current_tickets = nb_tickets 
    # Simuler un délai
    time.sleep(0.1)
    # Simuler une écriture dans la base de données
    nb_tickets  = current_tickets - 1
    print(f"Ticket acheté, tickets restants : {nb_tickets }\n")
  else: print("Plus de tickets disponibles.\n")

# Plusieurs utilisateurs essayant d'acheter des tickets en même temps

for _ in range(20):
  threading.Thread(target=achat_ticket).start()

Version avec verrou

import threading
import time

# Nombre de tickets disponibles (ressource partagée)
nb_tickets  = 10
lock = threading.Lock()

def achat_ticket():
  global nb_tickets
  with lock:
   if nb_tickets  > 0:
    # Simuler une lecture de la base de données
    current_tickets = nb_tickets 
    # Simuler un délai
    time.sleep(0.1)
    # Simuler une écriture dans la base de données
    nb_tickets  = current_tickets - 1
    print(f"Ticket acheté, tickets restants : {nb_tickets }\n")
   else: print("Plus de tickets disponibles.\n")

# Plusieurs utilisateurs essayant d'acheter des tickets en même temps

for _ in range(20):
  threading.Thread(target=achat_ticket).start()

Version SQL

import sqlite3

def buy_ticket(event_name):
    try:
        # Connexion à la base de données SQLite (ou création de la base si elle n'existe pas)
        conn = sqlite3.connect('example.db')
        cursor = conn.cursor()

        # Démarrer une transaction
        cursor.execute('BEGIN TRANSACTION')

        # Étape 1 : Vérifier le nombre de tickets disponibles
        cursor.execute('SELECT available_tickets FROM tickets WHERE event_name = ?', (event_name,))
        result = cursor.fetchone()

        if result is None:
            print(f"Événement '{event_name}' introuvable.")
            conn.rollback()
            return

        available_tickets = result[0]
        print(f"Tickets disponibles avant l'achat : {available_tickets}")

        if available_tickets > 0:
            # Étape 2 : Réserver un ticket
            cursor.execute('UPDATE tickets SET available_tickets = available_tickets - 1 WHERE event_name = ?', (event_name,))
            print("Achat réussi !")

            # Valider la transaction
            conn.commit()
        else:
            print("Échec de l'achat : plus de tickets disponibles.")
            conn.rollback()

    except sqlite3.Error as e:
        print(f"Erreur SQL : {e}")
        conn.rollback()
    finally:
        conn.close()

# Exemple d'utilisation avec plusieurs "acheteurs"
if __name__ == "__main__":
    # Création de la table et insertion initiale (exécuté une seule fois)
    conn = sqlite3.connect('example.db')
    cursor = conn.cursor()
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS tickets (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        event_name TEXT NOT NULL,
        available_tickets INTEGER NOT NULL
    )
    ''')
    cursor.execute('INSERT INTO tickets (event_name, available_tickets) VALUES (?, ?)', ('concert', 100))
    conn.commit()
    conn.close()

    # Simulation d'achats concurrents
    for _ in range(55): buy_ticket('concert')

Fuseaux horaires

from datetime import datetime
import pytz

# Obtenir l'heure actuelle en UTC
utc_now = datetime.now(pytz.utc)
print(f"Heure actuelle en UTC : {utc_now}")

for endroit in 'Europe/Paris', 'America/New_York', 'Africa/Cairo', 'Australia/Sydney', 'Asia/Tokyo', 'Antarctica/Troll':
 local_tz = pytz.timezone(endroit)
 local_time = utc_now.astimezone(local_tz)
 print(f"Heure locale {endroit} : {local_time}")

Phases de la lune

cycle_lunaire = 29.53058853
delta = cycle_lunaire / 8
phases = "Nouvelle lune","Premier croissant","Premier quartier", "Gibbeuse croissante","Pleine lune","Gibbeuse décroissante","Dernier quartier","Dernier croissant"
visuel = ['🌑','🌒','🌓','🌔','🌕','🌖','🌗','🌘']

def phase_lune(nb_jours):
 nb_cycles = int(nb_jours / cycle_lunaire)
 reste = nb_jours - nb_cycles * cycle_lunaire
 tranche = int(round(reste / delta, 0) % 8)
 return phases[tranche], visuel[tranche]

>>> phase_lune(365)
('Gibbeuse croissante', '🌔')

Calendrier chinois – signes du zodiaque

def zodiaque_chinois(annee):
 elements = "Bois", "Feu", "Terre", "Métal", "Eau"
 aspects = "Yang", "Yin"
 signes_zodiaque = (
        "Rat", "Buffle", "Tigre", "Lapin", "Dragon", "Serpent",
        "Cheval", "Chèvre", "Singe", "Coq", "Chien", "Cochon"
    )
 annee_ref = 1924 # Année du Rat, début d'un cycle de 60 ans
 diff_annees = annee - annee_ref
 ind_signe_zodiaque = diff_annees % 12
 ind_aspect = diff_annees % 2
 ind_element = (diff_annees % 10) // 2
 signe_zodiaque = signes_zodiaque[ind_signe_zodiaque]
 aspect = aspects[ind_aspect]
 element = elements[ind_element]
 annee_chinoise = annee_ref + (diff_annees % 60)
 return f"{annee_chinoise} : {signe_zodiaque} ({element} {aspect})"
 
>>> zodiaque_chinois(2024)
1964 : Dragon (Bois Yang)

Comparaison JULIEn | GREGORIEN | Personnel

def bissextile_julien(annee):
 return annee % 4 == 0
 
def bissextile_gregorien(annee):
 return (annee % 4 == 0 and annee % 100 != 0) or (annee % 400 == 0)
 
def bissextile_perso(annee):
 return annee % 4 == 0 and annee % 128 != 0
 
def compare(ans, methode):
 total = 0
 for an in range(ans):
  total += 365
  if methode(an): total += 1
 return total - 365.2421904482 * ans

>>> compare(10000, bissextile_julien)
78.09551799995825

>>> compare(10000, bissextile_gregorien)
3.095517999958247

>>> compare(10000, bissextile_perso)
-0.904482000041753