"return min(10, (num_participants // 50) + 1)"
var ju ett ganska intressant sätt att skriva:
"return 10"
med tanke på kontexten.

Svar till inlägg av Noterat , 2024-09-12 23:39:

Inte en aning

Svar till inlägg av PeterL, 2024-09-12 21:55:

MeOS hyllas ofta för smarta och enkla funktioner. Hur hanterar MeOS detta? Vet du?

Svar till inlägg av Zerbembasqwibo, 2024-09-12 21:26:

Snabbt koll av pseudokoden säger att den iallafall gör två fel (vilket man såklart kan säga åt den att fixa)
- Heatindelningen görs inte enligt regelverket (den verkar missat att utplaceringen är alternerande)
- Startgrupperna placeras i fel ordning i sammanslagningen samt vid ojämnt antal i grupperna placeras de extra löparna i fel seedningsgrupp

Med det sagt, OLA har väldigt bra stöd för lottning och finalheat enligt dagens regelverk så det går rätt smärtfritt. Vad andra gått bet på är svårt att säga men ifall man gör det första gången när det är skarpt läge så lär det ta tid oavsett hur bra stöd man har av system.

Svar till inlägg av Zerbembasqwibo, 2024-09-12 21:26:

Ja, vi kan hoppas!

Svar till inlägg av DrJ, 2024-09-12 20:47:

Men härligt, tänk om nån entusiast fixar till detta då!

Svar till inlägg av Zerbembasqwibo, 2024-09-12 20:23:

Då är det bara att addera det kravet och låta den generera en matchande kod. Och så ta nästa sak som blev lite knas och göra likadant.

Efter ca 4 år med kod-bottar i SW-organisationen som stöd inom den avancerade utvecklingen så är SW teamets slutsatser bl.a att ”skit in - skit ut”. En annan slutsats är ”rätt in - 1/3 av tiden för att generera koden mot att sätta teamet på att skapa den själva”.

Men självklart, med anpassning och integrering i befintlig kodmassa där mycket kopplingar redan finns utan definierade endpoints riskerar man att ändå få göra ett större arbete än bara be om en funktion som går att copy/paste.

Företag som idag livnär sig delvis på SW utveckling tror jag knappt finns kvar om 10-15 år om de inte använder kod-bottar. Om det går åt nåt håll blir det förr snarare än senare. AI expertisen säger typ 3-5år men det känns lite väl snabbt…

Den verkar skita i regeln om att två från samma klubb inte får starta efter varann.. slutade läsa där. :)

Jag frågade den allvetande skräphögen av idag, här är svaret att bedöma (ursäkta långt inlägg!):

Det verkar som att du behöver en programmeringslösning för att hantera heatindelning, seedning, lottning och lagsammansättning baserat på beskrivningen av SM-tävlingar inom orientering eller en liknande sport. Det finns flera aspekter av detta problem som kan brytas ned i olika delar, och en sådan lösning skulle behöva vara flexibel och anpassningsbar beroende på olika regler och antal deltagare.

Här är ett förslag på en kodstruktur för att hantera dessa regler och processer. Jag har valt Python som språk för att illustrera detta, men det kan implementeras i vilket modernt programmeringsspråk som helst beroende på vilka krav du har för applikationen.

Pseudokodstruktur och översikt
1 Heatindelning och finalplatser: Baserat på antalet deltagare, ska heatindelning ske och en A-final och B-X-finaler beräknas.
2 Seedning och ranking: Deltagare seedas baserat på en rankinglista och placeras i heat enligt reglerna.
3 Lottning: Lottning sker inom startgrupper och efter ranking.
4 Specialfall för finaltävlingar och sprintstafett: Särskilda regler för stafett, seedning för ultralång distans, natt och sprintstafett.



import random
from typing import List, Tuple

class Participant:
def __init__(self, name: str, ranking_points: int, district: str, club: str):
self.name = name
self.ranking_points = ranking_points
self.district = district
self.club = club
self.qualified_for_final = False

class Heat:
def __init__(self, participants: List[Participant]):
self.participants = participants

class Final:
def __init__(self, participants: List[Participant], final_type: str):
self.participants = participants
self.final_type = final_type # 'A', 'B', 'C', etc.

class Competition:
def __init__(self, participants: List[Participant]):
self.participants = participants
self.heats = []
self.finals = []

def distribute_participants_in_heats(self):
total_participants = len(self.participants)
num_heats = self.determine_number_of_heats(total_participants)
heat_participants = self.split_into_heats(self.participants, num_heats)

for group in heat_participants:
heat = Heat(group)
self.heats.append(heat)

def determine_number_of_heats(self, num_participants: int) -> int:
"""Bestäm antal kvalheat och deltagare per heat utifrån deltagartabellen."""
if num_participants <= 40:
return 1
elif 41 <= num_participants <= 80:
return 2
elif 81 <= num_participants <= 120:
return 3
elif 121 <= num_participants <= 160:
return 4
elif 161 <= num_participants <= 210:
return 5
elif 211 <= num_participants <= 264:
return 6
elif 265 <= num_participants <= 322:
return 7
elif 323 <= num_participants <= 384:
return 8
elif 385 <= num_participants <= 450:
return 9
else:
return min(10, (num_participants // 50) + 1)

def split_into_heats(self, participants: List[Participant], num_heats: int) -> List[List[Participant]]:
"""Fördelar deltagare i heat baserat på deras ranking."""
participants.sort(key=lambda p: p.ranking_points)
heat_groups = [[] for _ in range(num_heats)]

# Fördelar deltagarna enligt seedningsreglerna
for i, participant in enumerate(participants):
heat_index = i % num_heats
heat_groups[heat_index].append(participant)

return heat_groups

def seed_and_shuffle_heats(self):
"""Seedar deltagarna och genomför lottning inom respektive heat."""
for heat in self.heats:
heat.participants.sort(key=lambda p: p.ranking_points)

# Dela in i tre startgrupper (baserat på ranking)
first_group = heat.participants[:len(heat.participants)//3]
second_group = heat.participants[len(heat.participants)//3:2*len(heat.participants)//3]
third_group = heat.participants[2*len(heat.participants)//3:]

# Lottning inom varje grupp
random.shuffle(first_group)
random.shuffle(second_group)
random.shuffle(third_group)

# Sätt ihop heatet igen
heat.participants = first_group + second_group + third_group

def assign_final_qualification(self):
"""Bestämmer vilka deltagare som kvalificerar sig för finalerna."""
num_final_spots = self.determine_final_spots(len(self.participants))
top_ranked = sorted(self.participants, key=lambda p: p.ranking_points)[:num_final_spots]

for p in top_ranked:
p.qualified_for_final = True

self.create_finals(top_ranked)

def determine_final_spots(self, num_participants: int) -> int:
"""Beräkna antal finalplatser baserat på antalet deltagare."""
if num_participants < 40:
return num_participants
elif 41 <= num_participants <= 80:
return 40
elif 81 <= num_participants <= 120:
return 42
elif 121 <= num_participants <= 160:
return 40
elif 161 <= num_participants <= 210:
return 40
elif 211 <= num_participants <= 264:
return 42
elif 265 <= num_participants <= 322:
return 42
elif 323 <= num_participants <= 384:
return 40
elif 385 <= num_participants <= 450:
return 45
elif 451 <= num_participants <= 500:
return 50
else:
return min(55, num_participants)

def create_finals(self, top_ranked: List[Participant]):
"""Skapa finalerna baserat på kvalificerade deltagare."""
a_final = Final([p for p in top_ranked if p.qualified_for_final], 'A')
b_x_finals = Final([p for p in self.participants if not p.qualified_for_final], 'B-X')

self.finals.append(a_final)
self.finals.append(b_x_finals)

def print_heats(self):
for i, heat in enumerate(self.heats):
print(f"Heat {i+1}:")
for p in heat.participants:
print(f"{p.name} ({p.club}, Ranking: {p.ranking_points})")
print("\n")

def print_finals(self):
for final in self.finals:
print(f"{final.final_type}-final:")
for p in final.participants:
print(f"{p.name} ({p.club}, Ranking: {p.ranking_points})")
print("\n")

# Exempelanvändning
participants = [
Participant("Anna", 1000, "Stockholm", "Club A"),
Participant("Bertil", 1200, "Västra Götaland", "Club B"),
Participant("Cecilia", 900, "Skåne", "Club C"),
# Fler deltagare...
]

competition = Competition(participants)
competition.distribute_participants_in_heats()
competition.seed_and_shuffle_heats()
competition.assign_final_qualification()
competition.print_heats()
competition.print_finals()

Förklaring:
Klass Participant: Representerar varje deltagare, med information som namn, rankingpoäng, distrikt och klubb.
Klass Heat och Final: Representerar heaten och finalerna med en lista av deltagare.
Klass Competition: Ansvarar för att hantera heatindelning, seedning, lottning, och finalkvalificering.
distribute_participants_in_heats: Delar in deltagarna i heat beroende på antalet anmälda.
seed_and_shuffle_heats: Seedar deltagarna och lottar startordning.
assign_final_qualification: Bestämmer vilka som kvalificerar sig till finalen.
create_finals: Skapar finalerna.
Det här är en grundläggande lösning och kan utökas för att inkludera fler regler, som distriktsplatser, lagsammansättning, och olika specifika tävlingsregler för t.ex. ultralång distans och natt.

Använd gärna denna struktur för vidare utveckling av applikationen!

Svar till inlägg av A.I., 2024-09-12 12:35:

Ja, inte omöjligt

Svar till inlägg av Tord, 2024-09-12 10:18:

Chat GPT?

Svar till inlägg av Xet, 2024-09-12 07:59:

Lite småkomplicerat men bör inte vara några problem för en normalbegåvad utvecklare att skriva lite kod som fixar detta.

Svar till inlägg av zyx, 2024-09-12 06:39:

https://www.orientering.se/utova-och-folj/tavla/tavlingar/sm-usm-veteran-sm/forutsattningar-for-sm-deltagare/heatindelning-seedning-lottning-och-lagsammansattning-vid-sm/

I normala fall lottar alla program, som OLA och MeOS, enbart efter nån slumpalgoritm som också håller koll på att personer från samma klubb undviks att hamna efter varandra. Men i SM och SL så ska man dessutom använda olika rankinglistor. Tävlingar som har flera kvalheat och final är också med komplicerade.

Jag misstänker också att man är rädd för att göra minsta lilla fel och publicera en oriktig lista. Ibland så kan orienterare vara orimligt förbannade över misstag hos en arrangör.

Svar till inlägg av zyx, 2024-09-12 06:39:

Och vad gäller gemensam start - trots gemensam start (och ultralång) anses det viktigt att löparna står i rätt "rankingordning". Att ta fram ordningen var väl samma krångel som nämnts med svensk + världsranking + orankade dessutom - men där stöttade SOFT (det kostar också pengar?). I OLA behöver skapas en seedingsgrupp per löpare om jag förstod det rätt för att kunna tilldela exakt nummerlapp via en form av "lottning" sedan inom den gruppen med en löpare per grupp. (jag gjorde det inte själv utan SOFTs IT-coach och del av Peters "Emit-team" utförde det). Dvs INGET för amatörer. :D

Tid och pengar rullar. Kan vi inte göra det lite enklare för oss?

Svar till inlägg av zyx, 2024-09-12 06:39:

Jag gissar att det är SL:s regler att man har en världs och Sverigeranking att förhålla sig till när man seedar.

Från någon som inte är så insatt: Vad är det som gör det så komplicerat med seedningen?

Svar till inlägg av Princip, 2024-09-11 22:03:

Ja seedningen var inte enkel - inte ens för en SM-tävling med gemensam start! Och att peta in det i OLA kräver sin IT-tekniker.

Men vem vill förenkla eller programmera om OLA, dvs ta kostnaden för det?

Även om Peter och Emit fixade en del teknik så har också arrangörsklubbarna säkert haft häcken full för att fixa fram allt så snabbt som möjligt. Det är synd när SOFT har så pass komplicerade seedningsregler att klubbar måste köpa in experthjälp för att få fram startlistor i någorlunda tid...

Svar till inlägg av H21+, 2024-09-11 08:53:

Enkelt, här kommer dokumentationen i en mening: Det var Peter Löfås med sitt Emit-gäng som fixade startlistorna :-)
På Lång blev de dock fördröjda ett par timmar pga en kontrollfunktion som tog lite tid, men ändå klart mycket snabbare än de två senaste åren då arrangören jobbat med det själva. Kostade en slant, men arrangemangsmässigt känns det värt det (ekonomiskt lär det visa sig senare...).

Det kanske har skrivits här innan, men eloge till arrangören hur allt funkade vid årets sm tävlingar! För en gångs skull kom startlistor både till kval och finaler ut i tid både till lång och medelhelgen. Startlistan till medelfinalen måste legat ute nästan direkt efter sista målgång i kvalet kändes det som.

Kommande SM-arrangörer bör verkligen noga dokumentera hur man jobbade med detta iår för att kunna kopiera det.

Svar till inlägg av Nöjd, 2024-09-09 21:32:

Instämmer. Sveriges finaste orienteringsdistrikt.

Riktigt bra SM-arrangemang i Sörmland i år.

Svar till inlägg av ranking, 2024-09-09 10:45:

Kul detalj att samtliga i laget var med i Sveriges trupp till VM i Italien för tio år sedan.

Svar till inlägg av ranking, 2024-09-09 10:45:

I varje fall på herrsidan. Möjligen att Domnarvsdamerna var äldre när de vann för 10 år sedan.

Svar till inlägg av TG, 2024-09-09 06:11:

Hagaby måste ändå vara det lag med högst medelålder som tagit Stafett-SM guld? Jämfört med Stora Tuna på silverplats skiljer det 9-10 år per löpare. Men riktigt imponerande av Hagaby att vinna!

Svar till inlägg av +2, 2024-08-30 13:07:

Sena startlistor- Nej men sent PM.
Kartan- Nej, förutom att styrpunkterna var sabbade på GPS-sändningen.
Förbjudet område- Nej

Klagomålen har varit på USM, stängd grind- Distriktsrep istället för klubb rep. Gamlingar som vinner stafetten för H21. Tajt gaffel vs otajt gaffel.

Så jag hoppas att du inte bookmakade det oddset för då är du bankruppt. ;)

Svar till inlägg av Veteran SM, 2024-09-09 00:43:

Enligt de själva ja, men Regborn har inte fyllt 35 år.

Svar till inlägg av Veteran SM, 2024-09-09 00:43:

Gammal är äldst.

Svar till inlägg av H35a, 2024-09-08 22:54:

Veteranlag som vann h21klassen

Svar till inlägg av H35a, 2024-09-08 22:54:

Ja, ibland låter det som det bara är gamlingar som orienterar. Men om det är 736 st 17-34 år som springer SM medel så är ju det en riktigt bra siffra.

Svar till inlägg av Noterat , 2024-09-08 22:19:

Ok, så få. Överraskande.

43 st veteraner var med på Medel-SM

Svar till inlägg av Sudden, 2024-09-08 14:41:

Personligen tycker jag det är bra nivå. Egen orientering men också ganska tajt så att det blir stafett! Annars är det väl lika bra att köra individuella starter och räkna ihop tiderna…

SM-kartan har nån tagit in i OpenOrienteering mapper och sabbat styrpunkterna. Gissar jag.

Se på https://www.tulospalvelu.fi/gps/20240907SMmedelH21/ - det syns på små hjälpkurvshöjder att skrapen hamnar osymmetriskt. Var det så även på den tryckta kartan?

Fast det ser ju mestadels helt bra ut - vad har hänt?

Svar till inlägg av Västtrafik, 2024-09-08 19:54:

Topp 24 2024 måste firas!

Svar till inlägg av Västtrafik, 2024-09-08 19:54:

Okej - Ja
Udda - också ja.

Är det verkligen okej att fira en spurtstrid om en 24:e plats så mycket?

Svar till inlägg av Positiv, 2024-09-08 16:16:

+1

Tack Nyköpings OK för fantastiskt fina SM-tävlingar!