Les quipus sont un ancien dispositif utilisé par les Incas à l’époque précolombienne pour enregistrer les nombres dans un système de positions à dix positions de base sur un cordon, qui fonctionne comme suit:
Chaque groupe de nœuds est un chiffre et il existe trois types principaux de nœuds: les nœuds simples et simples; "nœuds longs", consistant en un nœud plat avec un ou plusieurs tours supplémentaires; et huit nœuds.
- Les puissances de dix sont indiquées par la position le long de la chaîne, et cette position est alignée entre les brins successifs.
- Les chiffres dans les positions pour les puissances supérieures ou égales à 10 sont représentés par des grappes de nœuds simples (par exemple, 40 correspond à quatre nœuds simples dans une rangée dans la position «dizaines»).
- Les chiffres dans la position "un" sont représentés par des nœuds longs (par exemple, 4 est un nœud à quatre tours). En raison de la manière dont les nœuds sont noués, le chiffre 1 ne peut pas être affiché de cette façon et est représenté dans cette position par un nœud en huit.
- Le zéro est représenté par l'absence de noeud dans la position appropriée.
Détails
Pour ce défi, chaque branche d'un quipu représente un nombre unique (bien que, comme le dit l'article de Wikipedia, vous pouvez représenter plusieurs nombres sur un seul volet, nous ne le ferons pas pour ce défi).
Noeuds
Chaque nœud sera représenté par un seul caractère ASCII.
.représente un nœud simple:représente un tour d'un noeud long8représente un noeud en huit|représente l’absence de noeud ainsi que de séparateur entre les chiffres.
Construire Quipus
Les Quipu sont construits en suivant ces règles.
- Les brins vont de haut en bas par ordre décroissant de position (comme dans, le chiffre des unités sera au bas d'un brin). Les chiffres le long d'un brin sont séparés par le caractère (
|). - La puissance de 10 que représente un chiffre est déterminée par sa position le long du brin de la même manière qu'une puissance de 10 chiffres serait calculée à l'aide de son index dans un nombre avec notre système de numération. C'est-à-dire,
24avec un2dans la position des dizaines et un4dans la position des unités, sera représenté par deux nœuds, un délimiteur (|), puis quatre nœuds. - Les chiffres dans la même position sont alignés vers le bas du brin. Si un chiffre dans une position aura moins de nœuds que les autres chiffres des autres nombres dans la même position, l'absence de ces nœuds est représentée par (
|). - Les nœuds simples consécutifs (
.) représentent une valeur dans leur position. - Chaque chiffre est représenté par au moins 1 caractère. Lorsqu'une valeur numérique est 0 pour tous les nombres d'un quipu, elle est représentée par l'absence d'un nœud (
|). - La place des unités est traitée spécialement. Un un dans la position des unités est représenté par un nœud en huit (
8). Une valeur de deux ou plus à la place des unités est représentée par des nœuds longs consécutifs (:). - Lorsque le chiffre des unités est 0 pour tous les nombres d'un quipu, l'absence de nœud n'est pas imprimée, mais le séparateur final du chiffre des dizaines est conservé.
- Il n'y a pas de délimiteur après le chiffre des unités.
Règles
- L'entrée consistera en une liste non vide d'entiers non négatifs pouvant être reçus via n'importe laquelle des méthodes d'entrée par défaut . Vous pouvez supposer que ces entiers sont tous inférieurs ou égaux à
2147483647ou2^31-1. Bien que les scénarios de test soient séparés par des espaces, votre format d’entrée peut séparer les entrées de la manière qui vous convient le mieux pour votre langue, qu’il s’agisse de séparer les virgules, les sauts de ligne, d’un tableau, etc. - La sortie consiste en un seul Quipu construit selon les règles décrites ci-dessus. La sortie peut être donnée par n'importe laquelle des méthodes de sortie par défaut .
- Votre code doit être un programme ou une fonction, bien qu'il ne soit pas nécessaire que ce soit une fonction nommée.
- Les nœuds prennent un certain temps à nouer, donc pour gagner du temps, votre code le plus court possible.
Comme toujours, si le problème n'est pas clair, merci de me le faire savoir. Bonne chance et bon golf!
Exemples
Contribution:
5 3 1 0
Sortie:
:|||
:|||
::||
::||
::8|
Contribution:
50 30 10 0
Sortie:
.|||
.|||
..||
..||
...|
||||
Contribution:
330
Sortie:
.
.
.
|
.
.
.
|
Contribution:
204 1
Sortie:
.|
.|
||
||
||
:|
:|
:|
:8
Contribution:
201 0 100 222
Sortie:
.||.
.|..
||||
|||.
|||.
||||
|||:
8||:
Contribution:
1073741823 2147483647
Sortie:
|.
..
||
|.
||
.|
.|
.|
..
..
..
..
||
|.
|.
|.
|.
..
..
..
||
.|
.|
.|
..
..
..
..
||
|.
|.
|.
|.
..
..
..
..
||
|.
|.
..
||
.|
.|
..
..
..
..
..
..
||
|.
|.
..
..
||
|:
|:
|:
|:
::
::
::
Contribution:
0
Sortie:
|
Réponses:
Python, 64 octets
Essayez-le en ligne!
Comment ça marche
la source
8. En fait, il ne s'agit que d'un8nœud lorsque le dernier chiffre est un 1 (voir règle 6). Vous convertissez tous les noeuds finaux et cela ne correspond pas à la spécification. De plus, essayez-le en ligne! le lien a apparemment un code différent de celui qui est affiché iciIllisible ,
31833001 octetsCe fut un défi amusant de travailler, de temps en temps, entre les fêtes de Noël. Merci d'avoir posté! La pratique du golf était intéressante car le cahier des charges est rempli d'exceptions et de cas particuliers, ce qui nécessitait de nombreuses conditions. De plus, bien que je n’aie pas eu besoin de convertir en décimales cette fois-ci, j’ai eu besoin d’une fonction de tri «max» pour déterminer le plus grand nombre de chiffres dans chaque nombre et la plus grande valeur des chiffres dans chaque emplacement.
La première version de ceci était 4844 octets, histoire de vous donner une idée de combien j'avais joué au golf.
Le programme attend l’entrée sous forme de liste d’entiers séparés par des virgules . Pas d'espaces ou de nouvelles lignes. Utiliser ceux-ci produira un comportement indéfini.
Explication
Je vais vous expliquer le fonctionnement du programme en vous expliquant comment il traite les entrées spécifiques
202,100,1.Au début, nous construisons quelques valeurs dont nous aurons besoin plus tard - principalement les codes ASCII des caractères que nous allons afficher.
Comme vous pouvez le voir
'8'et'.'sont déjà disponibles.'|'Cependant, c’est vraiment 124, pas 14. Nous utilisons une boucle while pour ajouter le double de la valeur temporaire de l’emplacement n ° 1 afin d’obtenir 124 (ce qui correspond à 14 + 55 × 2, car la boucle while s’exécute pendant 56−1 = 55 itérations). Cela économise quelques octets, car les littéraux de grand entier comme 124 sont très longs. Dans le diagramme suivant, je montre l'emplacement de chaque variable utilisée par le programme.Ensuite, nous voulons saisir tous les caractères et les stocker sur la bande à partir de la cellule 12 ( p est le pointeur courant pour cela). En même temps, nous voulons savoir quelle est la longueur du nombre le plus long (combien de chiffres). Pour ce faire, nous conservons un total cumulé en allant unaire à gauche à partir de la cellule # −1 (nous utilisons q comme pointeur en cours d'exécution). Après le premier numéro saisi (
202), la bande ressemble maintenant à ceci:Vous aurez sûrement remarqué que les nombres sont décalés de 4. Bien, lorsque nous les avons saisis pour la première fois, ce sont leurs valeurs ASCII. Ils sont donc «désactivés» par 48 et la virgule est 44. Pour chaque caractère, nous copions les 46 de
'.'dans r puis soustrayez-le avec une boucle while (qui soustrait 45) et ensuite nous ajoutons 1. Nous faisons cela pour que la virgule (notre séparateur) vaut 0, afin que nous puissions utiliser une condition pour le reconnaître.En outre, vous aurez remarqué que nous laissons la cellule 11 à 0. Nous en avons besoin pour reconnaître la limite du premier nombre.
Le prochain caractère sera une virgule, donc nous stockons un 0 dans # 15, mais bien sûr cette fois, nous n'avançons pas q . Au lieu de cela, nous avons mis q à 0 et commençons à «écraser» les 1 que nous avons déjà placés.
Une fois que tous les caractères restants ont été traités, nous obtenons ceci:
Comme vous pouvez le voir, les 1 écrits par q indiquent maintenant (en unaire) la longueur du nombre le plus long.
Nous utilisons maintenant une boucle while pour déplacer q à l'extrême gauche, puis plaçons un autre pointeur là-bas que j'appellerai r2 . Le but de R2 deviendra clair plus tard.
À ce stade, permettez-moi de clarifier la terminologie que je vais utiliser tout au long de cette étape.
Revenons maintenant à notre programmation régulière. Le reste du programme est une grande boucle qui avance q jusqu'à atteindre la cellule 0. Chacune des cellules situées le long du chemin représente un endroit, avec celles situées à l'extrême droite, et q commencera au plus significatif. Dans notre exemple, c’est la place des centaines.
Nous procédons en incrémentant la cellule q points à (c'est-à-dire, * q ).
Nous sommes maintenant à la «phase 2» pour la place des centaines. Dans cette étape, nous allons découvrir quel est le plus grand chiffre parmi tous les chiffres des centaines. Nous utilisons le même truc unaire, sauf que cette fois le pointeur s'appelle r et le pointeur r2 marque sa position de départ sur laquelle nous devons le réinitialiser à chaque fois que nous passons au nombre suivant.
Commençons par le premier numéro. Nous commençons par régler p sur 11 (la position de départ codée de manière irréversible de tous les nombres). Nous utilisons ensuite une boucle while pour trouver la fin du nombre et définissons p2 pour marquer la position. Dans le même temps, nous avons également mis q2 à 0:
Ne soyez pas distrait par le fait que q2 pointe dans les vars. Nous n'avons pas de remplissage d'une cellule vierge car nous pouvons détecter la cellule # 0 simplement parce que c'est le numéro zéro.
Ensuite, nous parcourons le nombre actuel en décrémentant ensemble p et q2 jusqu'à ce que * p soit égal à zéro. À chaque endroit, la valeur de * q2 nous indique ce que nous devons faire. 1 signifie «ne fait rien», alors nous continuons. Finalement, nous rencontrons le 2 dans la cellule n ° −3. Chaque fois que * q2 n'est pas égal à 1, q2 est toujours égal à q .
Comme je l'ai déjà indiqué, l'étape 2 consiste à «déterminer le chiffre le plus élevé à cet endroit». Nous définissons donc r sur r2 , utilisons une boucle while pour décrémenter * p , déplacez r vers la gauche et remplissez la bande avec des 1, puis utilisez une autre boucle while pour déplacer r vers la droite et incrémentez à nouveau * p pour restaurer la valeur. N'oubliez pas que chaque boucle while s'exécute pour une itération de moins que la valeur sur laquelle nous l'utilisons; pour cette raison, le nombre de 1 écrits sera 3 de plus (plutôt que 4 de plus) que la valeur du chiffre, et la valeur finale stockée dans * p sera de 2 de plus. Ainsi, cela a effectivement décrémenté * p par 2.
Après cela, nous définissons p à la valeur de p2 et nous recommençons tout cela. Pour la deuxième fois, définissez q2 sur 0, recherchez la fin du nombre en déplaçant p vers la droite, puis parcourez les chiffres de ce nombre en décrémentant ensemble p et q2 . Une fois encore, nous allons rencontrer le 2 dans la cellule # −3 et écrire qu'il reste beaucoup de 1 dans * r .
Dans le cas du troisième nombre, on finit par ne rien faire car il n'a pas une place de centaines (donc q2 n'atteint jamais q ), mais c'est correct car cela n'affecte pas le calcul de la valeur maximale du chiffre.
Nous définissons également la cellule * (r - 4) , que j'ai marquée d'une flèche sans étiquette ici, sur 1 (même si elle est déjà à 1). Je ne vais pas vous dire pourquoi encore, mais peut-être que vous avez déjà deviné?
L'incrément suivant de * q nous amène à l'étape 3, qui est «soustrayez le chiffre maximum de tous les chiffres du lieu actuel». Comme précédemment, nous réinitialisons p sur 11 et q2 sur 0, puis examinons tous les nombres comme nous l’avions fait à l’étape précédente; sauf que cette fois, * q = 3 au lieu de 2. À chaque fois que q2 rencontre q et que p est à des centaines, nous utilisons une boucle while pour décrémenter * p autant de fois qu'il y a 1 dans le bloc restant de * r2 (5 dans notre exemple) en utilisant rcomme un pointeur en cours d'exécution. Nous le décrémentons encore une fois pour que le chiffre le plus grand finisse à -2, pour une raison qui deviendra claire plus tard:
Après avoir traité tous les chiffres, nous en sommes maintenant à la fin de la troisième étape. Nous effectuons ici deux choses singulières.
Vous comprenez maintenant que nous continuons à parcourir les nombres, à trouver le lieu actuel (indiqué par la valeur non-1 de * q ) dans chaque nombre et à faire quelque chose en fonction de la valeur de * q . Nous voyons que * q est d'abord incrémenté à 2 (= calcule la valeur maximale du chiffre), puis 3 (soustrayez la valeur maximale de chaque chiffre à cet endroit), puis nous le soustrayons pour le rendre négatif. À partir de là, il continuera à monter jusqu'à atteindre 1, rétablissant ainsi la valeur qui signifie «ne rien faire». À ce stade, nous passons à l’endroit suivant.
Maintenant, quand * q est négatif, nous produisons. * q est exactement à la bonne valeur pour que nous puissions sortir le bon nombre de lignes de caractères avant qu'il atteigne 1; si le chiffre le plus grand est 2, nous devons générer 3 lignes. Voyons ce qui se passe à chaque valeur de * q :
'.'(point) ou un':'(deux points). Nous décidons lequel en regardant q : si c'est -1, nous sommes à la place de uns, donc':'nous produisons a (que nous calculons comme'8'+2), sinon a'.'.'|'(tuyau) puis incrémentons la valeur. De cette façon, il atteindra −2 au bon endroit, puis nous produirons'.'s /':'s pour le reste de ce chiffre.'|'(uniquement si out est différent de zéro, car sinon nous en sommes toujours aux étapes 2 ou 3).'.'(et la troisième sortie a'|'comme précédemment).'|'s indépendamment de * p ». De cette façon, nous obtenons le remplissage entre les chiffres.Maintenant, on incrémente q pour passer à l’endroit suivant, l’emplacement des dizaines, et on incrémente * q ici. Au début de l'étape 2, la bande ressemble à ceci:
Ensuite, nous effectuons la phase 2 comme avant. Rappelez-vous que ceci soustrait effectivement 2 de chaque chiffre de cet endroit et laisse également un nombre unaire de * r2 indiquant le chiffre maximum. Nous laissons le numéro unaire précédent et continuons d'étendre la bande vers la gauche; «nettoyer» ne coûterait que du code supplémentaire inutile. Lorsque nous avons terminé et que nous incrémentons * q , au début de l'étape 3, la bande est maintenant:
En fait, c'est un mensonge. Rappelez-vous plus tôt où j'ai dit que nous avons mis * (r - 4) à 1 et que je ne vous ai pas dit pourquoi? Maintenant je vais vous dire pourquoi. C’est le cas dans ce cas, où le chiffre le plus grand est en fait 0, ce qui signifie que tous les chiffres de cet endroit sont 0. Le réglage * (r - 4) , indiqué par la flèche non étiquetée ci-dessus, passe à 1 et prolonge le nombre unaire de 1, mais seulement dans ce cas particulier. De cette façon, nous prétendons que le chiffre le plus grand est 1, ce qui signifie que nous allons afficher une ligne supplémentaire.
Après l'étape 3 (soustrayez le nombre maximal de tous les chiffres de l'emplacement actuel), y compris l'étape supplémentaire qui rend * q négatif, la bande ressemble à ceci. La dernière fois, le plus gros chiffre était représenté par −2 dans le bloc * p , mais cette fois, ils sont tous −3 car ils sont tous en fait des zéros, mais nous prétendons que le chiffre maximum est un 1.
Voyons maintenant ce qui se passe lorsque * q progresse vers 1:
'|'s et les incrémentons.'|'parce que c'est ce que nous faisons toujours lorsque * q = 0, indépendamment de * p .Ainsi, nous obtenons deux rangées de tuyaux.
Enfin, nous nous déplaçons * q à sa place. Celui-ci devient intéressant car nous devons indiquer
':'s si le chiffre réel est différent de 1, mais'8'si c'est 1. Voyons comment se déroule le programme. Tout d'abord, nous incrémentons * q pour lancer l'étape 2:Après l'étape 2 («calculer la valeur maximale du chiffre»), il ne nous reste plus que:
Après l'étape 3 («soustraire la valeur numérique maximale de tous les chiffres de l'emplacement actuel»), la bande se présente comme suit:
Examinons maintenant chaque itération de * q :
':'(plutôt que'.'car q = −1).'|'et incrémente.'|'. Toutefois, cette fois, au lieu d’incrémenter, un cas particulier se déclenche. Seulement si nous sortons la dernière place ( q = −1), et que nous sommes dans l'avant dernière ligne pour cela ( * q = −2), et que le chiffre est en fait un 1 ( * p = −3) , alors au lieu de l’incrémenter à -2, nous le fixons à -1. En d'autres termes, nous utilisons -1 comme valeur spéciale pour indiquer que lors de la prochaine itération, nous aurons besoin de produire'8'au lieu de':'.':'.'|'. La condition spéciale ne se déclenche pas car * q n'est plus −2. Par conséquent, incrémentez.'8'.'|'s ici, mais dans le cas particulier où nous sommes à la place de uns ( q = −1), nous ignorons cela.Après cela, q est incrémenté à 0 et la boucle big while se termine.
Maintenant, vous savez comment une entrée
202,100,1fonctionne. Cependant, il y a un autre cas spécial que nous n'avons toujours pas couvert. Vous vous souviendrez peut-être que lors du traitement de la dernière position, lorsque * p était −3, nous le fixons à −1 pour le1(au lieu de l'incrémenter à −2) afin que l'itération suivante produise un à la'8'place. Cela ne fonctionne que parce que nous avons une itération dans laquelle * p est égal à −3 et que nous décidons de l'incrémenter ou de le définir sur −1. Nous n'avons pas une telle itération si tous les chiffres de la position des unités sont 0 ou 1. Dans un tel cas, toutes les * p valeurs pour les 1 commenceraient à −2; il n'y a aucune possibilité de décider de le mettre à −1plutôt que de l'incrémenter de -3 . De ce fait, il existe une autre condition de casse spéciale à l’étape 3 («soustrayez le chiffre maximum de chaque chiffre de l’emplacement actuel»). J'ai prétendu qu'après avoir soustrait la valeur de chiffre maximum de chaque chiffre (à quel point le chiffre maximum est à -1), nous le décrémentons encore une fois, mais en réalité, il existe une condition qui se présente comme suit:Si le chiffre que nous regardons est égal au chiffre maximum à cet endroit ( * p = −1), et que cet endroit est celui des unités ( q = −1), et que le chiffre maximum est 1 ( * (r + 5) = 0, c'est-à-dire que le bloc unaire à l'extrême gauche ne contient que 5 cellules), alors seulement , nous laisserons * p en -1 pour indiquer que la seule itération de la sortie doit générer un
'8'. Dans tous les autres cas, nous le décrémentons une fois de plus.Terminé. Bonne année!
Edit 1 (3183 → 3001): De bonnes fêtes de golf! J'ai réussi à me débarrasser entièrement des variables p2 et r2 ! p se bouscule maintenant pour trouver le début et la fin des nombres, mais il semble que le code soit plus court. J'ai aussi essayé de me débarrasser de q2 , mais je ne pouvais pas raccourcir le code de cette façon.
J'ai également trouvé quelques endroits supplémentaires où je pourrais appliquer des astuces de golf non lisibles typiques, comme réutiliser la dernière valeur d'une boucle while. Pour vous donner un exemple, au lieu de
Je peux sauver le
'""""(faites le premier, puis le second) et le'"""(constant 1) en l'écrivant de la même manièreBien sûr, cela ne fonctionne que si je sais que la boucle while sera exécutée pendant au moins une itération, mais si c'est le cas, sa valeur de retour est pd , je peux donc l'utiliser comme condition pour le if.
la source
Javascript (ES6)
750744690604498346245234 octetsJe suis nouveau à PPCG et j'ai pensé que je pourrais essayer celui-ci en pensant que c'était plutôt simple. Boy était je me suis trompé !! Cela fait un moment que je travaille dessus et j'ai beaucoup de golf à faire ... Les
suggestions sont encouragées! - Bien que donner un sens à cela ne soit pas chose facile.
Sort des cordes quand l'entrée est un tableau de nombres (par exemple:)
[204, 1].Explication
Exemple
Entrée: tableau de nombres:
[4,8,15,16,23,42]sortie:
la source
Python 3,
624598595574561535532527525426345328324294288286283280267265255251245238235234230228 octetsComme cette question nécessitait une réponse, j’en ai fourni une ici, où l’entrée devrait être une chaîne de nombres séparés par des espaces, tels que
"204 1". Boy, est-ce long? Toutes les suggestions de golf (ou de meilleures réponses) sont les bienvenues.Edit: Octets enregistrés en mélangeant des tabulations et des espaces.
Edit: J'ai sauvegardé beaucoup d'octets en changeant la façon dont j'ai obtenu les chiffres d'un nombre (faire une liste à partir de la chaîne de chiffres complétée de zéros, puis dans le corps du code, transposer pour obtenir des centaines de chiffres, dix chiffres, etc. .)
Edit: Et j'ai économisé un peu plus en incorporant cette dernière
:8boucle dans la boucle quipu principale.Maintenant, si seulement je pouvais comprendre pourquoiCompris et la solution prend trop d'octets. (Le nombre d'octets a également été supprimé car les onglets ont été redéfinis en quatre espaces. Il s'agissait probablement du format de bloc de code sur ce site)b=d[j*v+i]==m(d[i::v])ne fonctionne pas.Edit: j'ai réorganisé comment fait le quipus. Maintenant, il crée un brin à la fois, puis transpose pour l’impression.
Edit: a transformé ma réponse en un programme Python 3 pour enregistrer davantage d’octets.
Edit: j'ai trouvé un bogue dans mon code qui l'a fait de sorte qu'il n'imprimait pas correctement les zéros au milieu des nombres (voir le cas de test
204 1ci-dessus). En corrigeant cela, j'ai réussi à jouer au golf :)Edit: J'ai changé l'impression pour économiser 10 octets. Et je remets tous les vieux comptes d'octets en arrière, juste parce que.
Edit: Golfé l'attribution d'
vutilisermappour quatre octets. Crédit à CarpetPython , comme l’a leur réponse ici .Edit: Tourne le milieu "boucle pour dans une boucle", en une boucle pour six octets.
Edit: maintenant en utilisant
enumerate. Ne plus utiliserl=len(z). A transformé le ternaireif-elseen une liste ternaire. Voir ci-dessous pour plus de détails.Modifier: Sp3000 a suggéré d’éditer
printet d’éditer la condition ternaire qui enregistrait un octet.Ungolfed:
la source
0, comme0 12 4.for r in zip(*x):print(''.join(r))->print(''.join(r)for r in zip(*x))C,
238235 octetsS'appuyant fortement sur le préprocesseur C pour rendre le code aussi court que possible. En tant qu'effet secondaire, le rend également à peu près illisible.
Sur Ubuntu 14.04, vous pouvez compiler le code simplement
gcc quipu.c(ignorez les avertissements). Un exemple d'exécution de l'exécutable:Testé contre tous les cas de test de l'OP.
Code source non-golfé:
la source
Mathematica
436 453 357 352347 octetsCe qui précède
IntegerDigits; touche chaque chiffre avec des zéros à gauche (pour assurer un espacement égal); chaque numéro d'entrée, maintenant décomposé en chiffres, correspond à une ligne d'un tableau; chaque colonne représente une valeur de position. Le tableau est transposé.Exemple
la source
Transpose@Join? Cela devrait être à, non?R -
446444Je vois qu'il n'y a pas encore de solution R, alors en voici une. La fonction prend un vecteur avec des entiers.
Ungolfed
la source
if(v>0)de votreif(i<r)clause? Est-ce que R accepte une plage commez+1:zquandv==0? Si celaq[z+1:z,j]ne devait pas du tout être affecté, je penserais. Aussi, R a-t-il unelsemot clé et une sorte deelse ifmot clé? Si tel est le cas, vous pourrez jouer au golf avec certaines de ces conditions.if(v>0)est nécessaire car, siv=0, l’indice sera hors limites (c’est-à-dire qu’il essaiera d’obtenir la ligne suivante + 1). R l’a faitelse, et j’ai en fait essayé votre suggestion et utiliséelseautant que possible, mais il s’est avéré qu’il s’agissait du même nombre d’octets.