Contexte
Ada est un langage de programmation qui n'est pas exactement connu pour sa lacune.
Cependant, sa syntaxe littérale de tableau peut en théorie permettre des spécifications de tableau assez laconiques. Voici une description EBNF simple de la syntaxe littérale du tableau (passable à bottlecaps.de :
array ::= positional_array | named_array
positional_array ::= expression ',' expression (',' expression)*
| expression (',' expression)* ',' 'others' '=>' expression
named_array ::= component_association (',' component_association)*
component_association ::= discrete_choice_list '=>' expression
discrete_choice_list ::= discrete_choice ('|' discrete_choice)*
discrete_choice ::= expression ('..' expression)? | 'others'
Nous nous limiterons à des tableaux unidimensionnels d'entiers pour plus de simplicité. Cela signifie que nous n'utiliserons que des entiers pour les valeurs d'expression. Peut-être que dans un défi futur, nous pourrions essayer quelque chose de plus avancé (comme déclarer des variables et des tableaux multidimensionnels). Vous n'avez pas besoin de jouer au golf sur les littéraux entiers .
Voici quelques exemples de littéraux de tableau Ada et une représentation équivalente en python pour plus de clarté:
(1, 2, 3) = [1, 2, 3]
(1, others => 2) = [1, 2, 2, ..., 2]
(others => 1) = [1, 1, ..., 1]
(1 => 1, 2 => 3) = [1, 3]
(1|2 => 1, 3 => 2) = [1, 1, 2]
(1 => 1, 3 => 2, others => 3) = [1, 3, 2, 3, 3, ..., 3]
Défi
Le but de ce défi est de produire le littéral de tableau Ada le plus court pour un tableau d'entrée donné. Notez que les tableaux Ada peuvent commencer à partir de l'index souhaité, vous pouvez donc choisir ce que vous souhaitez que l'index de départ soit tant que chaque valeur est séquentielle. Dans cet exemple, je choisis de commencer à 1, ce qui est idiomatique pour Ada, mais vous pouvez choisir de commencer à n'importe quel autre entier.
Contribution
Votre entrée consistera en une liste d'entiers, sous la forme qui vous convient.
Production
Votre sortie sera une chaîne de texte représentant le littéral de tableau Ada valide le plus court qui représente la liste des entiers d'entrée. Vous pouvez utiliser n'importe quel index de départ que vous souhaitez sur ce tableau, mais votre choix (quel qu'il soit) doit être spécifié dans votre réponse (l'index de départ peut également être dynamique).
Les entiers doivent être représentés sous forme de nombres décimaux signés, comme dans les exemples. Ce défi ne couvre pas le golf de valeurs entières.
Exemples
Voici quelques exemples:
Simple: [1, 2, 3] -> (1,2,3)
Range: [1, 1, 1, 1, 1, 1, 1,] -> (1..7=>1)
Others: [1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1] -> (6=>2,others=>1)
Multiple Ranges: [1,1,1,1,1,2,2,2,2,2,1,1,1,1,1,2,2,2,2,2,1,1,1,1,1] -> (6..10|16..20=>2,others=>1)
Tiny Ranges: [1,1,2,2,1,1,1,1,1] -> (3|4=>2,others=>1)
Far Range: [[1]*5, [2]*100, [3]*5] -> (1..5=>1,6..105=>2,others=>3)
Alternation: [1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2] -> (1|3|5|7|9|11|13|15|17=>1,others=>2)
Big Number: [1234567890,1,1234567890] -> (2=>1,1|3=>1234567890)
Big-ish Number: [1234567,1,1234567] -> (1234567,1,1234567)
Solo: [-1] -> (1=>-1)
Huge Input: [[0],[1]*1000000000] -> (0,others=>1)
Positional Others: [1, 2, 3, 3, 3, 3, 3, 3] -> (1,2,others=>3)
Range and Choice, no Others: [1,1,1,12,12,3,3,3,3,3,3,3,3,3,3,4] -> (1..3=>1,4|5=>12,6..15=>3,16=>4)
Exigences minimales
Prend en charge au moins 100 numéros et entrées d'au moins 256 numéros.
Produire le résultat correct pour toutes ces entrées
- Comprend mettre les «autres» à la fin
- Comprend la mise en place d'un index pour les tableaux d'éléments uniques
Terminez (de préférence sur TIO) pour chacune des entrées ci-dessus en moins d'une minute.
La solution la plus courte en octets gagne!
Implémentation de référence
Cette implémentation utilise l'entrée comme tableau, chaque caractère étant un nombre. Les majuscules sont des constantes spéciales pour les grandes valeurs. L'argument du programme est l '«index de démarrage» à utiliser.
La section "code" du lien TIO est une solution correcte au problème, tandis que "l'en-tête" et le "pied de page" implémentent la structure de test.
la source
(-1)
?106..110=>3,others=>2
serait plus long) Le dernier cas doit avoir un index, car la grammaire n'autorise pas les tableaux positionnels à élément unique (positional_array ::= expression ',' expression (',' expression)*
)(1=>1,others=>1)
(1..100000000=>1)
(1|3=>1234567,2=>1)
s'agit d'une autre sortie valide pour[1234567,1,1234567]
?Réponses:
JavaScript (ES6),
307304 octetsEnregistré 2 octets grâce à @KevinCruijssen
C'est d'une longueur embarrassante ...
Essayez-le en ligne!
la source
'others=>'
.t
est utilisé avant d'être défini; la raison pour laquelle il ne plante pas est que les 2 premiers cas de test ne l'utilisent pas du tout; cela peut être facilement réparé sans frais, cependant.)'others'
deux fois et essayé de créer une variable sans changer la sortie. ;) Merci de l'expliquer cependant, et bon golf de la virgule en utilisant[,O]
. :)05AB1E ,
136134132 octetsEDIT: corrigé pour tous les cas de test maintenant.
Essayez-le en ligne ou vérifiez tous les cas de test (sauf celui «Huge Input», car il est trop gros).
Explication:
Voir cette astuce de mes 05AB1E (section Comment chaînes Compresser ne font pas partie du dictionnaire? ) Pour comprendre pourquoi
…ˆ†=>
est"others=>"
.la source