Musée Sisi billets : le comparateur de tarifs sur Scratch

Musée Sisi billets: le comparateur de tarifs sur Scratch

Le type de visite, le statut du visiteur, l’appartenance à un groupe scolaire et une éventuelle période de rénovation peuvent modifier le résultat.

Vienna

Billets et tarifs

Musée Sisi

★4,7/5 · 1 421 avisTarifs vérifiés le 27 août 2026Disponible à brève échéance

Billet d'entrée avec audioguide

1,5 h·★4,4·29 avis

dès35 €

Réserver des billets

Billet d'entrée de 2 heures avec audioguide

2 h·★4,5·46 avis

dès36 €−13 %

Réserver des billets

Visite guidée coupe-file

2–4 h·★4,7·227 avis

dès212 €

Réserver des billets

Visite guidée coupe-file de 2 heures

2 h·★4,7·1 119 avis

dès48 €−5 %

Réserver des billets

Billet officiel d'une journée

dès20 €

Réserver des billets

Billetterie officielle et achat en ligne

Plein tarif20 €

Enfant12 €

Tarif réduit18 €

Site officiel — sisimuseum-hofburg.at

Tarifs indicatifs, susceptibles de changer — prix et disponibilités confirmés sur la page du partenaire.Lien partenaire — billetterie GetYourGuide

Le Musée Sisi se trouve dans le palais impérial de la Hofburg, à Vienne. La visite peut associer le Musée Sisi, les appartements impériaux et un audioguide. Une visite guidée officielle constitue une autre option. Donc, un comparateur correct doit traiter plusieurs variables. Sinon, le programme donne un prix plausible, mais faux.

L’objectif est de construire un algorithme Scratch pour choisir le billet adapté. Les montants ne sont pas écrits directement dans les blocs. Ils sont stockés dans des variables. La grille tarifaire peut évoluer. Le programme reste donc modifiable sans changer toute la logique.

Un tarif n’est pas une valeur isolée. C’est le résultat d’une suite de conditions.

Structurer les données tarifaires du Musée Sisi

Scratch exécute les instructions dans l’ordre. Il ne comprend pas spontanément la différence entre un enfant, un étudiant, un groupe scolaire ou un adulte. Cette différence doit être représentée par des variables.

Les variables nécessaires

Créer d’abord les variables suivantes pour tous les sprites:

• âge: âge du visiteur;
• typeVisite: visite autonome ou visite guidée;
• statut: adulte, enfant, étudiant, personne en situation de handicap ou titulaire de la Vienna City Card;
• groupeScolaire: réponse indiquant si le visiteur appartient à un groupe scolaire;
• nombreVisiteurs: nombre de personnes concernées;
• travaux: réponse indiquant si la période de rénovation est active;
• tarifBase: montant avant réduction;
• tarifFinal: montant après application des règles;
• motifTarif: explication affichée à l’utilisateur.

La variable tarifBase contient le montant correspondant au type de billet choisi. La variable tarifFinal contient le résultat définitif. Cette séparation est indispensable.

Si le programme modifie directement tarifFinal à chaque étape, le débogage devient difficile. Or une erreur de priorité peut alors appliquer une réduction à un montant déjà réduit. Le résultat n’est plus contrôlable.

Ne pas confondre catégorie et réduction

Le tarif enfant constitue une catégorie. Le tarif étudiant constitue une réduction conditionnelle. Le groupe scolaire constitue une règle spécifique. Ces éléments ne doivent pas être codés comme une seule liste de profils.

Une structure correcte distingue au moins trois niveaux:

1. le type de visite;

2. la catégorie du visiteur;

3. la situation particulière du groupe ou de la période.

La grille peut être représentée ainsi:

Les montants exacts doivent être saisis à partir de la grille officielle utilisée pour l’exercice. Il ne faut pas les confondre avec les prix d’une excursion combinée ou d’un revendeur tiers.

Stocker les tarifs dans Scratch

Pour un exercice de collège, deux méthodes sont possibles.

La première utilise une variable par tarif:

• adulteAutonome;
• jeuneAutonome;
• reduitAutonome;
• scolaireAutonome;
• adulteGuide;
• jeuneGuide;
• reduitGuide;
• scolaireGuide.

Cette méthode est lisible. Elle convient à un premier programme.

La seconde utilise des listes. Une liste contient les catégories et une autre contient les valeurs associées. Cette méthode réduit le nombre de variables, mais elle introduit l’indexation. Il faut alors garantir que la position du tarif adulte reste la même dans toutes les listes.

Pour un comparateur destiné à des collégiens, les variables séparées sont préférables. Le programme contient davantage de noms, mais chaque affectation reste vérifiable.

Concevoir l’algorithme de sélection

Le programme doit poser les questions dans un ordre logique. Une question inutile ou mal placée crée une branche impossible.

Étape 1: demander le type de visite

Le programme commence par demander:

• visite autonome avec audioguide;
• visite guidée officielle.

La réponse peut être stockée dans typeVisite.

Dans Scratch:

• demander Quel type de visite choisissez-vous? autonome ou guidée? et attendre;
• mettre typeVisite à réponse.

Il faut ensuite contrôler la saisie. Si l’utilisateur écrit guide au lieu de guidée, le test exact échoue. Pour limiter cette erreur, le programme peut proposer une question numérique:

• saisir 1 pour la visite autonome;
• saisir 2 pour la visite guidée.

Une valeur numérique simplifie les conditions. Elle réduit aussi les erreurs liées aux accents et aux majuscules.

Étape 2: demander l’âge

Le programme demande ensuite l’âge. La réponse est stockée dans âge.

La règle de l’exercice doit être explicite:

• de 6 à 18 ans: catégorie enfant ou adolescent;
• de 19 à 25 ans: étudiant possible, avec justificatif;
• au-delà: catégorie adulte, sauf réduction particulière.

Il ne faut pas écrire seulement:

• si âge < 18, alors jeune.

Cette condition exclut l’âge de 18 ans. La borne correcte est:

• si âge ≥ 6 et âge ≤ 18, alors catégorie jeune.

Dans Scratch, le bloc logique et permet de combiner les deux tests.

Étape 3: traiter le groupe scolaire

Le groupe scolaire doit être détecté avant le choix général du tarif. La règle dépend de plusieurs conditions:

• l’âge doit appartenir à la tranche scolaire;
• le groupe doit compter au moins dix personnes;
• un formulaire scolaire doit être prévu.

Le formulaire peut être modélisé par une variable formulaireScolaire. Le programme demande alors:

• le nombre de visiteurs;
• la confirmation du formulaire.

La condition complète devient:

• si âge ≥ 6 et âge ≤ 18 et nombreVisiteurs ≥ 10 et formulaireScolaire = oui, alors appliquer le tarif scolaire.

Si une seule condition est fausse, la règle scolaire ne s’applique pas. Le programme doit donc passer à la catégorie jeune ordinaire.

L’ordre des conditions

L’ordre recommandé est le suivant:

1. vérifier la présence d’un groupe scolaire;

2. vérifier l’âge;

3. vérifier le statut ouvrant droit à une réduction;

4. sélectionner le type de visite;

5. appliquer éventuellement la remise liée aux travaux;

6. afficher le résultat.

Pourquoi placer le groupe scolaire en premier? Parce qu’un élève de 16 ans peut relever de deux catégories: jeune individuel ou groupe scolaire. La règle la plus spécifique doit être testée avant la règle générale.

Dans un algorithme, la condition la plus précise doit précéder la condition la plus large.

Utiliser les blocs « si… alors… sinon »

Scratch propose une structure conditionnelle simple:

• si <condition> alors
• sinon

Cette structure permet de choisir une branche. Elle ne permet pas, à elle seule, de traiter toutes les catégories. Il faut donc imbriquer plusieurs conditions ou utiliser des blocs successifs.

Sélection du tarif scolaire

La première branche peut suivre cette logique:

• si le visiteur appartient à un groupe scolaire valide:
• si typeVisite = autonome, mettre tarifBase à scolaireAutonome;
• sinon, mettre tarifBase à scolaireGuide;
• mettre motifTarif à groupe scolaire.

Cette branche s’arrête ensuite. Il ne faut pas appliquer aussi le tarif jeune individuel. Une seule catégorie doit être retenue.

Sélection du tarif jeune

Si le groupe scolaire n’est pas validé, le programme teste l’âge:

• si âge ≥ 6 et âge ≤ 18:
• si typeVisite = autonome, choisir jeuneAutonome;
• sinon, choisir jeuneGuide;
• mettre motifTarif à enfant ou adolescent.

Cette condition doit inclure les deux bornes. Les erreurs de comparaison sont fréquentes:

• âge < 18 oublie l’âge de 18 ans;
• âge > 6 oublie l’âge de 6 ans;
• âge ≥ 6 seul accepte aussi des adultes.

Il faut donc utiliser une condition composée.

Sélection du tarif réduit

Le tarif réduit ne dépend pas uniquement de l’âge. Il dépend aussi d’un justificatif ou d’un statut reconnu.

Créer une variable statut avec des valeurs contrôlées:

• aucun;
• étudiant;
• handicap;
• Vienna City Card.

Pour l’étudiant, la tranche d’âge doit aussi être testée. Un étudiant de 30 ans ne relève pas automatiquement de la même règle que l’étudiant de 19 à 25 ans prévue dans cette grille.

La condition devient:

• si statut = étudiant et âge ≥ 19 et âge ≤ 25, alors tarif réduit;
• sinon, si statut = handicap, alors tarif réduit;
• sinon, si statut = Vienna City Card, alors tarif réduit;
• sinon, tarif adulte.

Le programme doit demander la présence du justificatif lorsque cette information est nécessaire. Sans justificatif, le statut déclaré ne suffit pas dans la modélisation.

Choisir le tarif adulte

Le tarif adulte est la branche finale. Il ne signifie pas que l’âge est toujours supérieur à 18 ans. Il signifie que les règles plus spécifiques ont déjà été testées et rejetées.

La logique est donc:

• si le groupe scolaire est valide, tarif scolaire;
• sinon, si l’âge est compris entre 6 et 18 ans, tarif jeune;
• sinon, si un statut réduit valide est présent, tarif réduit;
• sinon, tarif adulte.

Cette structure est plus sûre qu’une série de tests indépendants. Avec des tests indépendants, plusieurs blocs peuvent modifier la même variable. Le dernier bloc exécuté écrase alors les résultats précédents.

Intégrer le type de visite sans dupliquer le programme

Une erreur classique consiste à écrire un programme complet pour la visite autonome, puis à recopier le même programme pour la visite guidée. Le fonctionnement devient long et les corrections doivent être faites deux fois.

La bonne méthode consiste à déterminer d’abord la catégorie, puis le type de visite.

Créer une variable categorie:

• scolaire;
• jeune;
• réduit;
• adulte.

Le programme suit alors deux étapes.

Première étape: déterminer la catégorie

• tester le groupe scolaire;
• sinon tester la tranche d’âge;
• sinon tester le statut réduit;
• sinon choisir adulte.

Deuxième étape: choisir le tarif dans la catégorie

• si categorie = scolaire:
• autonome donne scolaireAutonome;
• guidée donne scolaireGuide;
• si categorie = jeune:
• autonome donne jeuneAutonome;
• guidée donne jeuneGuide;
• si categorie = réduit:
• autonome donne reduitAutonome;
• guidée donne reduitGuide;
• si categorie = adulte:
• autonome donne adulteAutonome;
• guidée donne adulteGuide.

Cette séparation correspond à une fonction logique. La première partie répond à la question: qui visite? La seconde répond à la question: quelle formule est choisie?

Dans Scratch, cette organisation peut être placée dans deux blocs personnalisés:

• définir déterminer la catégorie;
• définir déterminer le tarif.

Les blocs personnalisés ne sont pas obligatoires. Ils rendent cependant le programme plus lisible et facilitent les tests.

Gérer la remise exceptionnelle pendant les travaux

La période de rénovation ajoute une règle temporelle. Pendant la phase indiquée du 6 octobre au 18 novembre, l’espace muséal Sisi peut être temporairement fermé et une réduction exceptionnelle est appliquée aux billets individuels.

Cette information doit être séparée du tarif normal. Il ne faut pas modifier les variables adulteAutonome, jeuneAutonome ou reduitAutonome. Ces variables décrivent la grille de référence. La remise est calculée ensuite.

Version simple avec une variable booléenne

Pour un exercice de collège, demander directement:

• La période de travaux est-elle active? oui ou non?

Puis stocker la réponse dans travaux.

La logique est:

• mettre tarifFinal à tarifBase;
• si travaux = oui et si la visite est autonome:
• calculer la réduction;
• modifier tarifFinal;
• sinon, conserver tarifBase.

La formule générale d’une réduction de 25 % est:

tarifFinal = tarifBase × 0,75

La priorité opératoire est claire. La multiplication est effectuée avant l’affectation à la variable. Une autre écriture consiste à calculer le montant de la remise:

remise = tarifBase × 0,25

puis:

tarifFinal = tarifBase - remise

Les deux méthodes donnent le même résultat si tarifBase n’a pas été modifié auparavant.

Version plus rigoureuse avec une date

Une version plus avancée demande le jour et le mois. Le programme doit alors tester une période qui traverse deux mois:

• date comprise entre le 6 octobre et le 31 octobre;
• ou date comprise entre le 1er novembre et le 18 novembre.

Il faut utiliser le bloc logique ou.

La condition ne peut pas être simplement:

• jour ≥ 6 et jour ≤ 18.

Cette expression accepte uniquement les jours 6 à 18, quel que soit le mois. Elle rejette les jours 19 à 31 octobre, qui appartiennent pourtant à la période.

Créer deux variables:

• jour;
• mois.

Puis appliquer:

• si mois = octobre et jour ≥ 6, alors travaux actifs;
• sinon, si mois = novembre et jour ≤ 18, alors travaux actifs;
• sinon, travaux inactifs.

Pour éviter les comparaisons textuelles, attribuer un nombre aux mois:

• octobre = 10;
• novembre = 11.

Le programme devient plus stable. Il faut cependant empêcher les dates impossibles, comme le jour 40 ou le mois 15.

Attention au type de billet

La remise exceptionnelle concerne les billets individuels dans la factualité utilisée pour cet exercice. Le programme doit donc tester typeVisite = autonome et, si nécessaire, groupeScolaire = non.

Une règle possible est:

• si travaux actifs et billet individuel autonome, appliquer la remise;
• sinon, ne pas appliquer la remise.

Le tarif scolaire doit rester traité par sa propre règle. Il ne faut pas supposer qu’une réduction individuelle s’applique automatiquement à un groupe d’élèves.

Calculer le prix pour plusieurs visiteurs

Le comparateur peut fonctionner de deux manières.

Prix par personne

Le programme calcule le tarif d’un visiteur:

• tarifFinal contient le montant individuel;
• afficher le tarif par personne;
• afficher la catégorie retenue.

Cette version est suffisante pour un exercice sur les conditions.

Montant total du groupe

Pour un groupe composé de visiteurs identiques, créer une variable total:

total = tarifFinal × nombreVisiteurs

La multiplication doit être effectuée après la sélection du tarif et après la remise éventuelle.

L’ordre est donc:

1. déterminer la catégorie;

2. déterminer le tarif de base;

3. appliquer la réduction autorisée;

4. multiplier par le nombre de visiteurs;

5. afficher le total.

Si le groupe contient des profils différents, un seul calcul ne suffit plus. Il faut répéter le traitement pour chaque catégorie ou utiliser une liste. Par exemple, une classe peut comprendre des élèves, un accompagnateur et plusieurs adultes. Le programme doit alors additionner plusieurs sous-totaux.

Une variable totalGroupe peut être remise à zéro au début:

• mettre totalGroupe à 0;
• traiter le premier profil;
• ajouter son sous-total à totalGroupe;
• recommencer pour le profil suivant.

La remise à zéro est obligatoire. Sans elle, le résultat d’une exécution précédente reste dans la variable.

Construire une interface Scratch contrôlée

Un programme de tarifs n’est pas seulement une suite de calculs. Il doit aussi limiter les saisies incohérentes.

Utiliser des choix numériques

Pour le type de visite:

• 1: autonome avec audioguide;
• 2: guidée.

Pour le statut:

• 1: aucun tarif réduit;
• 2: étudiant;
• 3: personne en situation de handicap;
• 4: titulaire de la Vienna City Card.

Pour le groupe scolaire:

• 1: oui;
• 2: non.

Les valeurs numériques rendent les conditions plus courtes. Elles évitent les différences entre Oui, oui et OUI.

Contrôler les valeurs

Le programme doit refuser:

• un âge négatif;
• un nombre de visiteurs inférieur à un;
• un type de visite différent de 1 ou 2;
• un âge inférieur à 6 ans si la grille étudiée commence à 6 ans;
• une demande de tarif étudiant hors de la tranche prévue.

Dans Scratch, une boucle répéter jusqu’à peut redemander une valeur tant qu’elle est invalide.

Exemple logique:

• demander l’âge;
• répéter jusqu’à âge ≥ 0:
• dire Saisissez un âge positif;
• demander l’âge;
• continuer le programme.

Le test âge ≥ 0 ne vérifie pas encore l’accès au tarif. Il vérifie seulement la validité de la saisie. Ces deux contrôles ne doivent pas être confondus.

Afficher la justification

Le programme doit afficher le tarif et sa cause:

• Catégorie: groupe scolaire;
• Formule: visite autonome;
• Tarif de base:...;
• Remise travaux: oui ou non;
• Montant final:....

La variable motifTarif évite une réponse opaque. Un résultat sans explication ne permet pas de repérer une erreur de branchement.

Tester et déboguer le comparateur

Un programme conditionnel ne se valide pas avec un seul exemple. Chaque branche doit être exécutée au moins une fois. Les valeurs situées sur les bornes sont prioritaires.

Scénarios de test

Utiliser une série de cas distincts:

1. Un adulte choisit la visite autonome.

Le programme doit sélectionner le tarif adulte autonome.

2. Un adulte choisit la visite guidée.

Le programme doit sélectionner le tarif adulte guidé. Le tarif ne doit pas rester celui de la visite autonome.

3. Un visiteur âgé de 6 ans choisit la visite autonome.

Le programme doit accepter la borne inférieure de la catégorie jeune.

4. Un visiteur âgé de 18 ans choisit la visite guidée.

Le programme doit encore utiliser la catégorie jeune.

5. Un visiteur âgé de 19 ans possède une carte étudiante valide.

Le programme doit sélectionner le tarif réduit étudiant.

6. Un visiteur âgé de 25 ans possède une carte étudiante valide.

Le programme doit encore accepter la borne supérieure.

7. Un visiteur âgé de 26 ans possède une carte étudiante.

Le programme doit appliquer la règle prévue par l’exercice, et non prolonger automatiquement la tranche 19-25 ans.

8. Un groupe de 9 élèves est déclaré comme groupe scolaire.

Le tarif scolaire ne doit pas être appliqué.

9. Un groupe de 10 élèves dispose du formulaire requis.

Le tarif scolaire doit être appliqué.

10. Une visite autonome est effectuée pendant la période de travaux.

La remise exceptionnelle doit être calculée une seule fois.

11. Une visite guidée est choisie pendant cette période.

Le programme doit suivre la règle définie pour les visites guidées. Il ne faut pas appliquer mécaniquement la remise individuelle autonome.

12. Une nouvelle exécution commence après une précédente.

Les variables totalGroupe, tarifBase et tarifFinal doivent être réinitialisées.

Les erreurs les plus fréquentes

Erreur 1: utiliser plusieurs blocs indépendants.

Un visiteur peut alors recevoir plusieurs catégories successives. Utiliser des blocs imbriqués ou une variable categorie.

Erreur 2: oublier une borne.

Les expressions âge > 6 et âge < 18 excluent les valeurs limites. Écrire les comparaisons complètes.

Erreur 3: appliquer la remise deux fois.

Si tarifFinal est multiplié par 0,75 dans deux branches, le résultat est diminué deux fois. Centraliser la remise dans une seule étape.

Erreur 4: multiplier trop tôt.

Le total du groupe ne doit pas être calculé avant le choix de la catégorie. Sinon, une modification du tarif individuel ne corrige pas le total déjà calculé.

Erreur 5: confondre billet officiel et offre commerciale.

Le comparateur pédagogique doit utiliser la grille officielle du Musée Sisi. Les tarifs d’une excursion, d’un transport combiné ou d’un revendeur ne doivent pas être intégrés dans la même variable.

Erreur 6: coder les montants dans chaque condition.

Cette méthode crée des répétitions. Stocker les montants dans des variables nommées. La modification de la grille devient alors locale.

Erreur 7: ne pas afficher la branche choisie.

Un résultat numérique seul ne révèle pas l’erreur. Afficher la catégorie, le type de visite et la remise.

Test de vérification rapide

Pour vérifier le programme, prendre un cas simple et suivre les variables à la main:

• typeVisite reçoit une valeur;
• categorie reçoit une seule valeur;
• tarifBase reçoit le tarif correspondant;
• tarifFinal est d’abord égal à tarifBase;
• la remise est appliquée au maximum une fois;
• totalGroupe est calculé à la fin.

Si une variable change deux fois sans justification, la structure contient probablement une erreur.

Le test le plus efficace porte sur les bornes: 6 ans, 18 ans, 19 ans, 25 ans, 26 ans, 9 visiteurs et 10 visiteurs. Les valeurs ordinaires masquent souvent les défauts. Les valeurs limites les révèlent.

Conclusion: un comparateur fiable suit une hiérarchie

Modéliser les billets du Musée Sisi avec Scratch revient à traduire une grille tarifaire en décisions ordonnées. Le programme ne doit pas deviner. Il doit appliquer une hiérarchie explicite:

1. identifier le type de visite;

2. vérifier le groupe scolaire;

3. classer l’âge;

4. contrôler le statut réduit;

5. choisir le tarif de base;

6. appliquer la remise temporaire si la règle l’autorise;

7. calculer le total;

8. afficher la justification.

Les variables représentent les données. Les conditions représentent les règles. Les tests représentent la vérification.

Le dernier contrôle est simple: choisir un cas, prévoir le résultat avant l’exécution, puis comparer avec la réponse de Scratch. Si le résultat diffère, il faut examiner les conditions, les bornes et l’ordre des blocs. Donc, le débogage commence par la logique, pas par l’apparence de l’interface.