Avez-vous des conseils pour le golf de code dans 05AB1E , un langage de golf créé par Adnan ?

Vos conseils devraient être au moins quelque peu spécifiques à 05AB1E.

Veuillez poster un pourboire par réponse.

Comme il ne faisait pas partie du wiki sur les pages GitHub de 05AB1E (je pense que cela devrait), je vais juste l'ajouter ici maintenant que je comprends mieux moi-même.

Comment utiliser le dictionnaire?

05AB1E a le fichier de dictionnaire words.ex suivant contenant tous les mots qu'il connaît. Mais comment accéder aux mots de ce dictionnaire? Prenons le mot "testing"comme exemple:

"testing"se trouve sur la ligne 1453 du fichier de dictionnaire. Puisque les deux premières lignes ne sont pas des mots et que nous avons besoin du mot indexé à 0, nous soustrayons 3.
Donc, maintenant nous avons l'index ( 1450), mais comment l'utiliser?

Nous ouvrons et commençons une chaîne compressée avec “† . Nous regardons ensuite la deuxième colonne du fichier info.txt . (Ainsi €vaut 00; ‚est 01; etc.)
Dans le cas de "testing"ce moyen î(14) et »(50).

La chaîne compressée pour "testing"est donc: “ Essayez-la en ligne. Comme avec presque tous les morceaux de code 05AB1E, la fin “est facultative si vous n'accédez pas à la chaîne, donc sans que cela fonctionne aussi dans ce cas .

Quelques points à noter:

Tous les caractères qui n'ont pas d'index dans le fichier info.txt peuvent être utilisés tels quels. Cela peut être utile pour ajouter un spour sortir un pluriel au lieu d'un mot singulier ou utiliser la ponctuation comme ,.?!par exemple.
ÿ(interpolation de chaîne) peut également être utilisé lorsque vous souhaitez insérer des valeurs de la pile dans la chaîne.
Remarque: chaque caractère lâche qui n'a pas d'index dans le fichier info.txt compte comme un mot pour les types de compression ci-dessous.

† Il existe différents types de chaînes compressées que vous pouvez utiliser:

• ': Prenez un seul mot compressé tel quel (pas de suivi 'requis) - 'î»: "testing"
• „: Prend deux mots compressés avec un délimiteur d'espace (aucun suivi „requis) - „î»î»: "testing testing"
• …: Prend trois mots compressés avec un délimiteur d'espace (pas de fin …requis) - …î»î»î»: "testing testing testing"
• “: Prenez la chaîne compressée avec un délimiteur d'espace - “î»î»“: "testing testing"
• ’: Prenez la chaîne compressée telle ’î»î»’quelle sans espaces implicites - : "testingtesting"
• ”: Prenez la chaîne compressée dans la casse du titre avec un délimiteur d'espace - ”î»î»”: "Testing Testing"
• ‘: Prenez la chaîne compressée en majuscules avec un délimiteur d'espace - ‘î»î»‘: "TESTING TESTING"

Voici un programme utile pour obtenir la chaîne compressée basée sur une entrée de mots délimitée par des espaces:

'“? lAð«Ã#¸˜ vyU "€‚ƒ„…†‡ˆ‰Š‹ŒŽ•–—™š›œžŸ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîï" Dâ vy"“ÿ“".V XlQi y?1#] '“,

Essayez-le en ligne.

Ce programme:

1. Prendre l'entrée en minuscules, supprime tous les caractères non alphabétiques (sauf pour les espaces), puis divise les mots par des espaces ( lAð«Ã#), ou encapsule les mots dans une liste si un seul mot a été entré ( ¸˜)
2. Boucles sur chaque mot ( vyU)
3. A ensuite une boucle interne sur chaque mot compressé du dictionnaire ( "€...ï"Dâvy), qu'il essaiera d'exécuter en tant que programme 05AB1E ( "“ÿ“".V)
4. Et s'il est égal au mot actuel, il l'imprimera et rompra la boucle intérieure XlQiy?1#

Avec une entrée, good bye worldla sortie serait donc “‚¿Þ¡‚ï“. Essayez-le en ligne.

REMARQUE: vous devez toujours voir si le mot existe dans le dictionnaire pour que ce générateur fonctionne, et il ignorera tous les caractères spéciaux ou les mots pluriels. Seuls les mots exactement identiques dans le dictionnaire seront trouvés.

Voici un exemple où j'utilise …Ÿ™‚ï!pour la chaîne "hello world!" et ’‚¿Þ¡ ÿ ‚ï!’pour la chaîne "au revoir ÿ monde!". Notez comment les espaces et le point d'exclamation sont utilisés tels quels, car ils n'ont pas d'index dans le fichier info.txt. De plus, il utilise ÿpour insérer le "cruel" qui était en haut de la pile, qui malheureusement ne faisait pas partie du dictionnaire (mais qui était quand même compressé en utilisant la méthode de la section ci-dessous).

Comment compresser des chaînes ne faisant pas partie du dictionnaire?

Bien que le fichier du dictionnaire words.ex soit assez volumineux (10 000 mots pour être exact), il peut arriver que vous ayez besoin d'un mot qui n'en fait pas partie, ou d'une chaîne qui est tout simplement du charabia. Existe-t-il un moyen de les compresser également?
Il y a certainement, en utilisant .•, une chaîne compressée basée sur l'alphabet base-255. REMARQUE: cette méthode ne peut être utilisée que pour les caractères de l'alphabet minuscule et les espaces.

Voici un programme utile pour convertir un mot / chaîne en une chaîne basée sur l'alphabet base-255 compressé:

vAyk})> 27β 255B ".•ÿ•"

Essayez-le en ligne. .

Ce que fait ce programme ci-dessus est:

• vAyk})>: Prenez les index alphabétiques à 1 index des lettres individuelles de l'entrée, les espaces devenant l'index 0
• 27β: Convertir ces indices de la base 27 en un seul nombre
• 255B: Convertissez ce nombre en Base-255 en utilisant la propre page de codes de 05AB1E
• ".•ÿ•": Place un début .•et une fin •avant cette chaîne compressée

Voici un exemple de réponse où @Kaldo utilise .•zíΘ•pour compresser le mot "oie".

Comment compresser les grands entiers?

Disons que nous voulons utiliser un très grand nombre pour quelque chose, mais il ne peut pas vraiment être récupéré par des calculs de puissance. Par exemple, disons que nous voulons accéder au grand entier 18238098189071058293pour une raison quelconque.

Dans ce cas, nous pouvons utiliser à la fois un début et un retour •pour compresser un nombre au format [1-9][0-9]+.
Le numéro d'exemple ci-dessus deviendra •15Y₁Ò'Θpc•. Essayez-le en ligne. Encore une fois, tout comme avec la chaîne de dictionnaire compressée, la fin •peut éventuellement être supprimée .

Facultativement, lorsque l'entier est suffisamment petit pour que seuls 2 caractères compressés doivent être utilisés, nous pouvons utiliser à la Žplace, auquel cas nous n'aurons pas besoin d'un octet de fin pour le fermer et l'entier est compressé en 3 octets au lieu de 4. Pour Par exemple, l'entier 13562entraînerait •rl•, mais comme il n'utilise que deux caractères, il peut l'être à la Žrlplace.

De plus, les nombres dans la plage [101, 355]peuvent être compressés sur 2 octets en utilisant Ƶplus un caractère supplémentaire de la page de codes 05AB1E. Ainsi, par exemple, Ƶ–peut être utilisé pour l'entier 250. Voici un aperçu de tous les numéros disponibles. Ces caractères sont convertis de Base-255 en Base-10, puis 101 est ajouté (puisque les nombres dans la plage [0,100]sont déjà 1 ou 2 octets).

Comment sont-ils créés 15Y₁Ò'Θpcet rlcréés? Très simple, le nombre est converti en Base-255 en utilisant la propre page de code de 05AB1E. Vous pouvez donc utiliser le programme suivant pour obtenir un numéro comprimé, pour lequel il utilisera alors Ƶ., Ž..ou en •...•fonction de la taille de l'entier comprimé:

101 355Ÿså i 101-255B"Ƶÿ" ë 255B Dg2Qi "Žÿ" ë "•ÿ•"

Essayez-le en ligne.

Voici un exemple de réponse où @Emigna utilise •3Èñ•pour l'entier 246060.

Comment compresser des listes entières?

Parfois, vous souhaitez compresser une liste entière d'entiers au lieu d'un seul nombre. Par exemple, disons que nous voulons la liste [5,93,17,83,4,44,32,19,4,45,83,90,0,14,3,17,17,81]pour une raison quelconque. Dans ce cas, nous pouvons utiliser les éléments suivants à la place: •4βŸ{©£MG]q‡dZΘp•94в Essayez-le en ligne.

Voici un programme utile pour générer à la fois ce nombre compressé et la base que nous voulons convertir:

Z>© β 255B ®s"•ÿ•ÿв"

Essayez-le en ligne.

Ce que fait ce programme ci-dessus est:

• Z>: Récupère le nombre max + 1 de la liste d'entrées ( ©: et le stocke dans le registre)
• β: Convertir la liste d'entrée de la base max+1en un seul numéro
• 255B: Compressez ce numéro unique (comme nous l'avons fait dans la section ci-dessus)
• ®s"•ÿ•ÿв": Renvoie le résultat au format: début •, nombre compressé,, •max + 1, finв

Voici un exemple de réponse où j'utilise •4Œ”dóŒfÝŸĀTUÕáOyÖOÀÁàu¼6¹₆Žr‡_›y³eß₂©ǝ²ƶ"SAÎAñ'¡û†Ø(•91вpour compresser la liste [85,30,29,39,28,37,33,88,31,40,34,89,35,41,32,90,36,38,42,43,44,60,45,61,46,62,47,63,48,64,49,65,81,50,66,51,67,52,68,53,69,86,54,70,87,55,71,56,72,82,57,73,79,80,58,74,59,75,76,77,78,83,84].
PS: Dans cette réponse •6j|eDEJÞó(ÍêΓλùÄÞKüzHÇ-ø`JδŠ₂+Öηôî®À8†6/ðÎ6ùøΓ°ÓĆ;ˆ©Ā•2ôest une alternative à octets égaux (57), puisque tous les nombres ont exactement deux chiffres. Dans certains cas (en particulier les petites listes), cela peut être une alternative plus courte.

Compression entière vs compression de liste entière:

Avec ces deux, cela peut aller dans les deux sens. Parfois, une liste compressée est plus courte, parfois un entier compressé, parfois une alternative complètement différente est plus courte. Donc, utilisez toujours votre propre jugement et vos compétences de golf pour éventuellement jouer au golf, au lieu de vous fier entièrement aux générateurs ci-dessus. Voici quelques exemples:

[44, 59]( utilisé dans cette réponse de @Emigna ):

• •A–•60в est de 7 octets (généré par le générateur de liste d'entiers compressés)
• •H|•2ôou •H|•2äou codés en dur 44 59‚sont tous 6 octets
• ŽH|2ôou ŽH|2äsont tous les deux 5 octets
• Mais dans ce cas, „,;Çavec 4 octets serait la meilleure option (points de code des caractères ',' et ';')

[2,4,6,0]( utilisé dans cette réponse de @Emigna ):

• •3ā•7в est de 6 octets (généré par le générateur de liste d'entiers compressés)
• Ž3ā7в est de 5 octets
• Mais dans ce cas, Ž9¦Savec 4 octets serait la meilleure option (entier compressé 2460 à une liste de chiffres)

10101001100101001( utilisé dans ma réponse ):

• •a½₄Ƶ6®í• est de 9 octets (généré par un générateur de grands nombres compressés)
• •1∊}•2вJ est de 8 octets (généré par un générateur de liste d'entiers compressé avec jointure ajoutée)
• Mais dans ce cas, •1∊}•bavec 6 octets serait la meilleure option (liste d'entiers compressés, avec un à binaire au lieu de 2в, qui rejoint implicitement)

[85,30,29,39,28,37,33,88,31,40,34,89,35,41,32,90,36,38,42,43,44,60,45,61,46,62,47,63,48,64,49,65,81,50,66,51,67,52,68,53,69,86,54,70,87,55,71,56,72,82,57,73,79,80,58,74,59,75,76,77,78,83,84]( utilisé dans ma réponse ):

• •4Œ”dóŒfÝŸĀTUÕáOyÖOÀÁàu¼6¹₆Žr‡_›y³eß₂©ǝ²ƶ"SAÎAñ'¡û†Ø(•91в est de 57 octets (généré par le générateur de liste d'entiers compressés)
• •6j|eDEJÞó(ÍêΓλùÄÞKüzHÇ-øJδŠ₂ + Öηôî®À8 † 6 / ðÎ6ùøΓ ° ÓĆ; ˆ © Ā • 2ô` est également 57 octets (entier compressé, divisé en parties de taille 2)
• •Bšā¿ÑáζΔÕæ₅"®GÙ₂®°ƶío"§óÏ4¸bćÔ!₃ùZFúÐìŸ ,λ₂ϦP(Ì•65в₂+est cependant 2 octets plus court, en compressant la liste avec chaque valeur 26 inférieure, puis en ajoutant ensuite avec "₂ + " . Cette astuce consistant à ajouter une valeur à un octet plus tard peut être utilisée assez souvent pour enregistrer des octets dans des listes compressées.

Entrée implicite

À l'époque où 05AB1E était sorti, les entrées implicites étaient assez nouvelles et fantaisistes. De nos jours, cela semble nécessaire pour suivre les autres langages concurrents (comme Jelly, MATL, Pyth, etc.).

Par exemple, lorsque vous souhaitez ajouter deux nombres, vous pouvez faire II+:

I    # Input_1.
 I   # Input_2.
  +  # Add them up.

Testez-le ici

Cependant, en utilisant une entrée implicite , nous pouvons raccourcir à seulement 1 octet, à savoir +:

+    # Take two numbers implicitly and add them up.

Testez-le ici

Cela se produit uniquement lorsque la longueur de la pile est inférieure à l'arité de l'opérateur. Un dernier exemple est 3+. L'arité de l' +opérateur est 2 alors qu'il n'y a que 1 élément dans la pile:

3    # Push the number 3 on top of the stack.
 +   # Request implicit input and add to the 3.

Testez-le ici

Sous-chaînes

£est la commande pour prendre les premiers bcaractères de la chaîne a.
ex: "hello_world"5£ -> "hello"

Mais si best une liste d'indices, il divise la chaîne en parties de (jusqu'à) ces tailles.
ex: "hello_world"5L£ -> ['h', 'el', 'lo_', 'worl', 'd']

Variables prédéfinies

Ils sont un peu cachés dans 05AB1E. Voici une liste de toutes les variables prédéfinies:

• ¾, pousse 0si la contre_variable n'est pas modifiée avant cette commande.
• X, pousse 1si la variable X n'est pas modifiée avant cette commande avec U.
• Y, pousse 2si la variable Y n'est pas modifiée avant cette commande avec V.
• ®, pousse -1si le registre n'est pas modifié avant cette commande avec ©.
• ¯, pousse [](tableau vide) si rien n'est ajouté au global_array avant cette commande.
• ¸, pousse [""]sur une pile vide s'il n'y a pas d'entrée. (Merci @Emigna d'avoir trouvé celui-ci.)

Utilisation du canevas ( Λou .Λ)

Comme il ne faisait pas partie de la documentation et que @Adnan est actuellement un peu trop occupé pour l'écrire, j'ai demandé la permission de l'ajouter comme astuce ici pour l'instant.

La fonction Canvas ( Λou .Λ) peut être utilisée pour tracer des lignes ASCII à l'écran. Il a trois paramètres requis:

• a Longueur: taille de la ou des lignes. Il peut s'agir d'un seul entier ou d'une liste d'entiers
• b Chaîne: le ou les caractères que nous voulons afficher. Cela peut être un seul caractère, une chaîne, une liste de caractères ou une liste de chaînes (dans les trois derniers cas, il les utilisera tous un par un, y compris le bouclage)
• c Direction: La direction dans laquelle les lignes de caractères doivent être tracées. En général, nous avons les chiffres[0,7]des directions, pour lesquels nous pouvons utiliser un ou plusieurs. Il existe également des options spéciales qui nécessitent un certain caractère (plus à ce sujet plus tard).

Les chiffres des directions [0,7]correspondent aux directions suivantes:

7   0   1
  ↖ ↑ ↗
6 ← X → 2
  ↙ ↓ ↘
5   4   3

Un exemple 05AB1E répond où le canevas est utilisé:

• Imprimer un négatif de votre code
• Octogones d'art ASCII
• Tours Eiffel: Créez un grand «A» à partir de «A»
• Faites un projecteur alphabétique!
• Une spirale ASCII bien espacée

Faisons quelque chose de similaire au dernier, supposons donc que nous utilisons la Λfonction Canvas avec les trois paramètres suivants:

• a :[3,3,5,5,7,7,9,9]
• b :!@#
• c :[0,2,4,6]

Cela donnera la sortie suivante:

  !@#!@#!
  #     @
  @ #!@ #
  ! @ # !
  # ! ! @
  @   @ #
  !#@!# !
        @
@!#@!#@!#

Essayez-le en ligne.

Alors, comment ça marche? Eh bien, voici les étapes avec ces entrées ci-dessus:

1. Dessinez des 3caractères ( !@#) vers le haut (direction 0)
2. Dessinez des 3-1caractères ( !@) vers la droite (direction 2)
3. Dessinez des 5-1caractères ( #!@#) vers le bas (direction 4)
4. Dessinez des 5-1caractères ( !@#!) vers la gauche (direction 6)
5. Dessinez des 7-1caractères ( @#!@#!) vers le haut (direction 0)
6. Dessinez des 7-1caractères ( @#!@#!) vers la droite (direction 2)
7. Dessinez des 9-1caractères ( @#!@#!@#) vers le bas (direction 4)
8. Dessinez des 9-1caractères ( !@#!@#!@) vers la gauche (direction 6)

Ils -1sont là parce que les lignes se chevauchent. Les deux premières étapes sont donc:

#
@
!

Et

 !@

Ce qui est combiné:

#!@
@
!

Quelques notes mineures:

• Outre les options, [0,7]il existe quelques options spécifiques disponibles, qui se traduisent essentiellement par une certaine séquence de direction.
  • +(en '+ligne) se traduit par le motif 04402662, ce qui crée un +croisement avec des bras de la longueur donnée. Voyez-le en action.
  • ×(en '×ligne) se traduit par le motif 15513773, ce qui crée un Xcroisement avec des bras de la longueur donnée. Voyez-le en action.
  • 8revient à l'origine d'où nous avons commencé à dessiner. Voyez-le en action et voyez la différence sans8 .
• La fonction intégrée Canvas ajoutera implicitement des espaces de fin pour faire de la sortie un rectangle.
• Le Λsortira immédiatement et produira .Λune chaîne qui est poussée dans la pile, que nous pouvons toujours réutiliser, modifier et faire tout ce que nous voulons. Quelques exemples:
  • Nous pouvons le convertir en une liste de chaînes ou en une liste de caractères .
  • On pourrait remplacer un certain personnage
  • Insérez un certain caractère
  • etc.

Pop ou get

Comme dans d'autres langages basés sur la pile , les fonctions de 05AB1E pop (consomment) généralement leurs entrées de la pile et poussent leurs sorties sur la pile.

Cependant, certaines fonctions obtiennent leurs entrées de la pile sans les consommer. Un exemple est la headfonction, ¬qui produit le premier élément de la liste d'entrée. Voir ici un exemple de programme: ¬+. Cela ajoute le premier numéro de la liste d'entrée à chaque numéro de cette liste.

Pour savoir quelles fonctions apparaissent et lesquelles sont récupérées, consultez la colonne correspondante dans le fichier d'informations sur les fonctions .

Conditionnelles et boucles

Les boucles et les conditions reçoivent automatiquement des crochets de fermeture à la fin d'un programme, vous n'avez donc besoin de les ajouter dans le code que si vous avez besoin de quelque chose en dehors de la boucle / conditionnel.

Par exemple, ce programme (non golfé) créant une liste des npremiers nombres premiers n'a pas besoin de parenthèses fermantes. [¹¾Q#NpiNˆ¼

Mais si nous voulions effectuer une opération sur la liste résultante, par exemple en prenant des delta, nous devons d'abord fermer la boucle. [¹¾Q#NpiNˆ¼]¯¥

Petits conseils de golf 05AB1E

Développera cela avec de petits conseils de golf que j'ai appris en cours de route. (Je viens de commencer 05AB1E personnellement.)

• D(duplicate) et Ð(triplicate) en combinaison avec s(swap) et Š(triple-swap a,b,cto c,a,b) sont généralement plus courts que l'utilisation de ©(save in global_variable ) et ®(push global_variable ) à l'intérieur des boucles. Cela a sauvé un octet dans ma réponse , ainsi que deux dans cette réponse .
• ½(si 1, alors augmentez counter_variable de 1) n'est pas nécessaire à la fin d'un µ(alors que counter_variable ! = a, do ...), car c'est fait implicitement ( enregistré un octet dans cette réponse ).
• .Bse divise implicitement sur les nouvelles lignes. Cela a été utile dans ma réponse lorsque nous recherchions une alternative pour ¡(fractionner) tout en conservant les éléments vides (REMARQUE: la solution dans la réponse liée ne fonctionne pas lorsque les éléments contiennent des espaces de fin après la séparation.) - Espérons qu'un bloc intégré être ajouté au fractionnement mais garder les lignes vides à l'avenir.
• SÖ(lequel des chiffres de l'entier en entrée peut diviser uniformément l'entier en entrée) contiendra le numéro lui-même pour les chiffres 0(au lieu des erreurs de division par zéro). Par exemple, 1053entraînera[1,1053,0,1] (1053 est divisible par 1 et 3; n'est pas divisible par 5; et donne une erreur de division par zéro pour 0). Cela a été assez utile dans ma réponse en prenant le pouvoir de la liste, car seul 1est vrai en 05AB1E et tout le reste est falsey. SÖPrésultant en truey ( 1) signifie donc qu'un entier en entrée est divisible de façon égale par chacun de ses chiffres.
• Après avoir vu û(palindromiser une chaîne donnée), j'ai été surpris qu'il n'y ait pas de code intégré is_palindrome. Mais plus tard, j'ai réalisé que seulement 2 octets étaient nécessaires pour accomplir cela, qui sont ÂQ(où Âest bifurqué, qui est l'abréviation de DRDuplicate & Reverse copy; etQ est de vérifier si les deux premières valeurs de la pile sont égales).
• Lorsque vous souhaitez filtrer une liste par plusieurs éléments, il est généralement moins coûteux d'avoir plusieurs filtres lâches plutôt que tous combinés en un. Parce que lorsque vous avez deux filtres, vous aurez besoin de quelque chose dans le sens de Ds*(dupliquer, échanger, multiplier pour agir comme logique-ET) vs }ʒ(fermer le premier filtre, filtrer à nouveau) lorsque vous utilisez deux filtres. Par exemple: dans ce défi, nous devons répertorier tous les nombres de quatre chiffres, contenant au moins un 0, et avec une somme de chiffres égale à 9. L'utilisation d'une plage [1000,10000]couvre le nombre de quatre chiffres, mais vous vous retrouvez avec deux autres filtres. Initialement, j'ai utilisé ₄4°ŸʒD0åsSO9Q*(14 octets), mais en utilisant deux filtres, un octet peut être enregistré: ₄4°Ÿʒ0å}ʒSO9Q(13 octets). (Qui a ensuite été joué au golf ₄4°ŸεW°ö9Q(10 octets) par @Grimy.)
• Lorsque vous souhaitez compresser avec un entier 0comme remplissage, vous pouvez utiliser 0ζ. Cependant, un problème avec cela est que le remplissage 0deviendra une chaîne "0", donc si vous essayez plus tard de trier avec des chaînes mixtes et des nombres entiers, cela ne donnera probablement pas le résultat souhaité. Voici un exemple de la façon dont il triera les listes intérieures zippées: 0ζ€{. Cela peut être corrigé en ajoutant un casting explicite int ( ï) après la fermeture, et seulement puis trier: 0ζï€{. Cependant, en utilisant la ¾constante as 0avec le zip-filler, il restera un entier au lieu d'une chaîne pendant le zip. Vous ¾ζ€{économiserez donc un octet ici. Cette astuce a été fournie par @ Mr.Xcoder pour enregistrer un octet dans ma réponse .
• Si vous souhaitez additionner les chiffres de plusieurs nombres dans une liste, vous pouvez utiliser €SO. Cependant, plus court utilise 1ö, qui vectorise automatiquement. Cette astuce a été fournie par @Grimy pour enregistrer un octet ici (et 2 octets ici ).
• Si vous ne traitez qu'avec des entiers non négatifs et que vous souhaitez vérifier à l'intérieur d'un filtre s'il s'agit de 0 ou de 1, vous pouvez bien sûr utiliser l'évidence 2‹. Cependant, l'utilisation de !(factoriel) n'entraînera également que 1 (véridique) pour 0et 1, et toute autre valeur entraînera quelque chose de plus élevé (et donc de falsey, car seule 1est véridique dans 05AB1E). Cette astuce a été fournie par @Grimy pour enregistrer un octet ici .

Vectorisation automatique

Notez que certains opérateurs de 05AB1E vectorisent automatiquement sur les tableaux. Par exemple, le code 5L3+, qui se démonte au pseudocode suivant:

[1, 2, 3, 4, 5] + 3

deviendrait:

[4, 5, 6, 7, 8]

S'il ne vectorise pas automatiquement, vous pouvez également utiliser l' €opérateur. Il prend une commande à un seul caractère et exécute cet opérateur (monadique) sur chaque élément. Un exemple pour diviser chaque élément est le code suivant ( essayez-le ici ):

€S

Alors que l' Sopérateur normal divise chaque élément du tableau et l'aplatit en un seul tableau ( essayez-le ici ).

Ordre des entrées

L'ordre que vous prenez en entrée peut avoir un effet drastique sur votre code et, souvent, si vous utilisez spour échanger le haut de la pile avec la prochaine chose la plus élevée de la pile, vous ne pensez pas correctement au problème. Essayez de réorganiser les entrées et voyez si vous pouvez vous débarrasser de la nécessité de permuter en échangeant les entrées à l'avance, en les ajoutant à la pile plus tôt ou en les dupliquant quelque part. L'I & O le plus évident peut être la réponse 05AB1E la moins réussie.

05AB1E Golf ASCII-Art

Le code ci-dessous permet de transformer l'art ASCII en 05AB1E à l'aide d'une conversion de base personnalisée.

|»©ÐÙSDŠ¢øΣθ}R€н¬®sÅ?iD2£RDŠKsì}J©žLR‡®gö₅B®s"•ÿ•“ÿ“ÅвJ"

Essayez-le en ligne.

Ceci est accompli par:

1. Liste des caractères uniques dans le dessin ASCII.
2. Triez-les par le nombre de fois qu'ils apparaissent dans la chaîne dans l'ordre décroissant (des caractères les plus fréquents aux moins fréquents).
3. Inversez les deux premiers éléments si le dessin ASCII commence par le caractère le plus fréquent (pour éviter les premiers 0 dans l'entier compressé).
4. Mappez les caractères de l'entrée 0-9A-Za-zdans cet ordre, chaque caractère distinct obtenant son propre caractère de mappage, jusqu'à ce que chacun ait été remplacé.
5. Base compressez-la, en utilisant la base la plus élevée que vous deviez remplacer (en fonction du nombre de caractères uniques).
6. Base le reconvertit en base-255 (pour la compression 05AB1E).
7. Format tout dans le format suivant : •<compressed_integer>•“<sorted_distinct_characters>“ÅвJ.

Le “vous permet également de compresser des guillemets "; le Åвutilisera cette chaîne pour convertir en base l'entier généré en utilisant la chaîne comme base personnalisée; etJ réunira tous ces caractères en une seule chaîne, qui est implicitement sortie.

Accepte les motifs avec jusqu'à 62 caractères uniques inclus, bon pour l'art ASCII.
Moins il y a de caractères uniques, meilleure est la compression.

Exemple de sortie pour dessiner le chronogramme numérique XNOR (214 octets, 9 caractères uniques):

    ┌─┐ ┌─┐ ┌─────┐ ┌─┐ ┌─┐ ┌───┐  
A ──┘ └─┘ └─┘     └─┘ └─┘ └─┘   └──
  ┌───┐ ┌───┐ ┌─┐ ┌─────┐   ┌─┐ ┌─┐
B ┘   └─┘   └─┘ └─┘     └───┘ └─┘ └
    ┌─────┐   ┌─┐   ┌─┐   ┌───┐   
X ──┘     └───┘ └───┘ └───┘   └────

Serait:

05AB1E , 106 octets

•I£.µ*:]ó±øqaµb₄ΘYQmœ¹µû₄p´ζÂĆ_5ŠKÑ×ðòË|₄#¹¶úôÂ-Í|¯ε¼É₂ïδ&é–9»ÞFò1î×HÃBjý2ĆÉ≠FYÂÂèC j‘£Å₅Œ•“─ └┘┐┌
XBA“ÅвJ

Essayez-le en ligne.

(106/214) * 100 = 49,53% de la taille de la chaîne ASCII originale.

C'est le même nombre d'octets que ma soumission réelle pour ce défi dans 05AB1E (hérité).

Explication du code:

REMARQUE: Le code n'est absolument pas joué. Il est rapidement écrit pour convertir l'art ASCII en compression la plus efficace, donc c'est assez laid et long ..

|»               # Take multi-line input
  ©              # Store it in the register to reuse later                         
ÐÙS              # Only leave unique characters (as list)
   DŠ¢ø          # Map it with the count for each of those characters
       Σθ}R      # Sort it based on that count (highest to lowest)
           €н    # Remove the count again, so the sorted characters remain
¬®sÅ?i           # If the input starts with the most occurring character:
      D2£RDŠKsì} #  Swap the first two characters in the list
J©               # Join everything together, and store it in the register to reuse later
  žLR‡           # Map each character to [0-9A-Za-z]
      ®gö        # Get the amount of unique characters, and convert it to that Base
         ₅B      # And then convert that to Base-255
®s               # Push the string and swap so the compressed integer is at the top again
  "•ÿ•“ÿ“ÅвJ"    # Insert it in the correct output format
                 #  `•<compressed_integer>•“<sorted_distinct_characters>“ÅвJ`
"•ÿ•"            # (after which the result is output implicitly with trailing newline)

Les chaînes et les entiers sont de types égaux

Pas quelque chose avec lequel tout le monde est d'accord, mais cela fonctionne.

Considérez les deux programmes suivants:

4 5+
"4""5"+

Ils aboutissent tous les deux à 9 . En effet, chaque valeur est d'abord évaluée (avecast.literal_eval ). Pour cette raison, nous pouvons effectuer tous les opérateurs de manipulation de chaînes sur les entiers et tous les opérateurs de manipulation int sur les chaînes.

Par exemple, 12345ûpalindromise le nombre 12345, ce qui donne 123454321. Après cela, nous pouvons faire le calcul régulier sur ce nombre.

12345û50000-

Il en résulterait: 123404321 .

Boucles et itérateurs cachés

05AB1E a les boucles et les itérateurs normaux suivants:

• F, qui itère jusqu'à 0 .. n-1 .
• G, qui passe par 1 .. n-1 .
• ƒ, qui itère jusqu'à 0 .. n .
• v, qui itère sur chaque élément s [0], s [1], .., s [n] .
• ʒ, qui n'est pas exactement une boucle, mais une commande de filtrage . Nous abusons de cette commande pour son comportement inattendu de bouclage à travers chaque élément.

En utilisant ces boucles, nous pouvons dériver les boucles cachées suivantes :

• Au lieu de gF, vous pouvez utiliser vqui a également un N-index qui peut être utilisé.
• Le vy -> ʒremplacement est un peu plus délicat:
  • Vous devez imprimer immédiatement les résultats. Cela supprime l'impression automatique de l'impression du haut de la pile.
  • L'extrait de code est exécuté sur une nouvelle pile temporaire . Cela signifie que les extraits de code dépendant de la pile ne peuvent pas être utilisés.
  • L'invocation yn'est pas possible dans ce type de boucles.