GolfScript obtient trop souvent son propre chemin et je pense qu'un répertoire de conseils pratiques pour jouer au golf en J pourrait aider dans la lutte contre l'empire du mal. Quels conseils avez-vous pour raccourcir ce langage déjà laconique?

Pour ceux qui souhaitent apprendre J, le point de départ évident est le site jsoftware et en particulier le vocabulaire , le guide Learning J et le guide des programmeurs J for C.

Il y a un certain nombre de subtilités pour éliminer les derniers caractères de J. Pour ce qui suit, supposons que chaque majuscule est un verbe primitif (c'est-à-dire que je supprime les espaces qui seraient autrement nécessaires pour délimiter les noms).

• Lorsque vous avez un train en cours et que vous devez appliquer une fonction au sommet d'une autre à mi-chemin ([:FLGR)et (LF@:GR)avoir le même nombre de caractères, mais en (LF@GR)enregistre un. Si le cadre de G est supérieur ou égal au rang de monade de F, c'est une transformation valide. Notamment, tous les trains ont un rang infini, tout comme la , ,. ,: ~. /: \: [ ]plupart des utilisations de #et |..

• Si vous devez sélectionner des chaînes dans une liste et que ces chaînes n'ont pas d'espace, utilisez >i{ab`cd`ef. C'est sale, mais il enregistre des caractères pour chaque nouvelle chaîne que vous devez traiter, à moins que vous ne tiriez que des caractères uniques, et même dans ce cas, la liste de caractères doit être de longueur 4 pour être plus courte. Ce qui se passe, c'est que les noms non définis sont traités comme des références aux verbes, et lorsque vous prenez les gérondifs de ces verbes, vous obtenez une chaîne encadrée du nom. Tous les noms qui sont déjà définis comme ayant un nom, un adverbe ou une conjonction de type ne peuvent pas être utilisés de cette manière, car ces noms sont résolus avant de `pouvoir y avoir.

• Si vous avez la chance d'avoir une expression avec laquelle travailler et pas seulement un verbe tacite, cela vaut presque toujours la peine d'attribuer tous les bits que vous réutilisez à des variables, qu'il s'agisse de noms, de verbes ou d'adverbes. Les parens se rentabilisent parfois en s'intégrant à l'endroit où vous aviez des espaces auparavant, et la plupart de ces définitions en valent la peine si elles sont réutilisées une fois de plus.

• Des conjonctions comme (FGH)^:(u`v`w)peuvent être réécrites u`v`w(FGH^:). Cela fonctionne pour n'importe quelle longueur de train, même 1, même si vous n'enregistrez rien si cette astuce supprime les parens du bon argument. Cette astuce ne fonctionne que lorsque vous préchargez l'opérande de gauche. (Vous n'avez aucune idée de ce qui vient de se produire? Recherchez des adverbes tacites et étudiez la section Analyse et exécution du dictionnaire J.)

• N'utilisez pas a.&i., utilisez u:! {&a.et 3&u:sont équivalents sur la longueur, cependant, et le premier pourrait être plus utile dans une conjonction (selon la conjonction).

• Des choses comme (2%~F)et (F%2:)sont de longueur équivalente. C'est utile parce que parfois, selon l'apparence du reste de votre train, vous pouvez le restructurer avec des @astuces comme écrit au premier point, pour sauver des personnages désespérés. (Et bien sûr, si Fc'est le cas ]et que le train est une monade, l'utilisation %&2sauve un char, duh.)

• Trains en forme de crochet avec ]ou [comme verbe le plus à gauche, par exemple (]FGH).

  • ]vous permet de diviser une application dyadique et d'utiliser uniquement le bon argument. (Échangez à gauche avec (]FGH)~, à une pénalité d'au moins 1 caractère, peut-être plus.) Enregistre un caractère plus (FGH)@], et est très pratique dans les gérondifs!
  • [dans un crochet appliqué monadiquement vous permet de faire quelque chose pour les effets secondaires du côté droit, puis de renvoyer l'argument à nouveau. L'utilisation la plus courante est avec 1!:2, peut-être avec le formatage indésirable.

• Les E / S sont nulles. Accélérez le processus en faisant des boucles avec tout ce que vous pouvez. 1!:1a un rang 0, et les deux 1!:2 3ont un rang _ 0, par exemple, alors utilisez-le en créant des tableaux de 1 et passez 1!:1directement dessus. Notez qu'il a ".également le rang 1, vous pouvez donc généralement le mettre directement après 1!:1, et ne pas avoir à le joindre via @ou à classer les manigances.

• Ce n'est pas facile de trouver des endroits où mettre cela, mais cela ::peut être utile.

  • ::]^:_est une combinaison particulièrement puissante, par exemple, qui vous permet de faire quelque chose de dangereux jusqu'à ce que vous ne puissiez plus le faire. (Sous réserve des ^:_mises en garde habituelles en boucle.)

  • Cela vous permet également d'utiliser {sur des listes qui n'ont pas l'index souhaité, car cela génère une erreur de domaine lorsque cela se produit. Utile, par exemple, pour prendre la tête d'une liste uniquement si elle existe (essayez d'utiliser ::]pour renvoyer la liste vide, ou ::_1:pour renvoyer un code d'erreur, etc.).

• ]`($:@u)@.vpeuvent généralement être raccourcis u^:v^:_, en particulier sur les définitions de uet vqui peuvent être utilisés avec. Un cas similaire est valable pour le conditionnel comme u^:(1-v)contre ]`u@.v. Considérez vos options, surtout lorsque vous avez beaucoup de verbes nommés flottant. C'est aussi un peu plus flexible, mais rappelez-vous, si vous l'utilisez $:, il y a une profondeur de récursivité avec laquelle il est facile de se heurter. (Habituellement, quelque chose comme 1800 itérations?)

La chose la plus importante lorsque vous jouez au golf en J est non seulement de comprendre le problème, mais de le réduire à une série de transformations de tableau. Vous devez comprendre cette façon de penser pour réussir avec le code J.

Par exemple, un défi récent a demandé de résoudre le plus grand problème de sous- réseau . L'algorithme de stock pour résoudre ce problème est l'algorithme de Kadane a la description informelle suivante:

Parcourez le tableau et à chaque position et trouvez la somme du plus grand sous-tableau se terminant ici, qui est le maximum de 0 ou la valeur à l'indice actuel plus la somme du plus grand sous-tableau se terminant à la position précédente. Calculez le maximum de ces sous-réseaux au fur et à mesure pour trouver le plus grand sous-tableau de l'ensemble du tableau.

Une traduction en code impératif est simple:

1. soit A le tableau d'entrée.
2. h ← m ← i ← 0.
3. si i ≥ len (A) retourne m .
4. h ← max (0, h + A [ i ]).
5. m ← max ( m , h ).
6. i ← i + 1.
7. goto 3.

Cet algorithme semble compliqué pour J à première vue car il existe une boucle explicite qui ne ressemble pas à une réduction au premier abord. Si vous vous rendez compte de ce que fait l'algorithme, vous pouvez démêler les étapes individuelles et voir qu'il effectue en fait deux opérations de tableau simples:

1. Parcourez le tableau pour calculer les longueurs des plus grands sous-réseaux se terminant à chaque index.
2. Réduisez ces longueurs avec la fonction max pour trouver le maximum.

Maintenant, ces deux étapes sont très faciles à implémenter en J. Voici une traduction:

1. (0 >. +)/\. y , 0- Cette étape opère à l'autre extrémité du tableau pour mieux s'adapter au paradigme de J. 0 >. +est tacite 0 >. x + y.
2. >./ y

Ensemble, nous obtenons une implémentation très concise de l'algorithme:

>./ (0 >. +)/\. y , 0

Si vous apprenez cette façon d'aborder l'implémentation des algorithmes, vos solutions seront aussi laconiques que ce code.

Voici quelques astuces que j'ai accumulées au fil du temps. Cette liste sera élargie au fur et à mesure que j'acquérirai plus de connaissances en golf J.

• Apprenez le dictionnaire. Il contient beaucoup de verbes vraiment obscurs qui n'ont aucun sens tant que vous ne voyez pas leur utilité. Par exemple, monadic =est étrange au début, mais est très utile dans les défis artistiques ASCII.
• Utilisez dyadique &dans des contextes tacites lorsque vous voulez une conjonction de pouvoir. Le vocabulaire suggère u@[&0un remplacement tacite à 4 : 'u^:x ymoi et moi aussi.
• Dans de nombreux cas, vous pouvez éviter un [:ou @:dans une séquence comme u@ven choisissant une variante uqui a un argument de gauche. Par exemple, pour supprimer le premier élément du résultat de v, utilisez 1}.vau lieu de [:}.vsi ce }.@vn'est pas possible pour une raison quelconque.
• ] vest souvent plus court que v@]si vous souhaitez utiliser monadic vdans un contexte dyadique. Cela est utile surtout quand il vy a un long train de verbes.
• Parfois, vous pouvez écrire m (n v w) yau lieu de (n v m&w) y. Cela peut permettre d'éviter les espaces et les parenthèses.
• #\au lieu de >:@i.@#.
• u &. vest utile quand va un avers. Sinon, vous pouvez utiliser [: vinv u & vou à la u & (v :. vinv)place.
• Comprendre le classement et comment l'utiliser. Essayez de jouer avec la conjonction de rang jusqu'à ce que vous obteniez quelque chose qui vous convient. Il aide à comprendre comment le classement influence votre code.
• ^:_ est extrêmement utile pour les algorithmes où vous souhaitez atteindre la convergence, comme un remplissage ou des simulations.
• Connaissez votre bibliothèque standard. Il contient des fonctions très utiles qui vous permettent d'économiser des tonnes de caractères.
• Les copules =.et =:peuvent être intégrés n'importe où dans une phrase. Utilisez-le pour créer des lignes simples où la notation tacite ne suffit pas.
• Utilisez des réductions monadiques ,au lieu de plusieurs réductions lors de la réduction de tableaux multidimensionnels.
• Comprenez quelles expressions sont prises en charge par du code spécial lorsque le défi impose des limites d'exécution. Certaines choses utiles fonctionnent dans O ( n ) au lieu de O ( n ² ) de manière contre-intuitive.
• Les boîtes sont utiles pour les arbres.

Méfiez-vous des boucles.

Alors que J a des structures en boucle ( for. do. end., while. do. end.et variations), si vous vous trouvez à les utiliser , il y a une possibilité que votre algorithme ne joue pas aux forces de golf de J et qu'il ya des économies de caractère à effectuer.

^:la conjonction de puissance est votre amie. Pour exécuter un verbe xfois:

verb^:x

Si vous avez besoin du résultat de chaque itération dans une liste:

verb^:(i.x)

Vous pouvez également utiliser ^:pour exécuter un verbe conditionnellement:

  +:^:(3<])"0[ 1 2 3 4 5 6
1 2 3 8 10 12

Doublez +:si ^:l'élément est supérieur à 3 3<](le "0change le rang du verbe pour qu'il fonctionne un élément à la fois).

Contribution

1!:1[1 prendra une ligne d'entrée terminée en appuyant sur la touche Entrée.

1!:1[3 prendra un certain nombre de lignes d'entrée (terminé par Ctrl-D sur mon Mac, Ctrl-C sur Windows).

Si vous essayez de saisir des nombres, l'utilisation ".évaluera la chaîne et renverra une liste de nombres prêts à être manipulés. Si vous saisissez un numéro mais devez opérer sur les chiffres individuellement ".,.(grâce au commentaire de Jan Dvorak pour cela) ou "."0diviserez la chaîne en chiffres séparés:

   "."0[1!:1[1
12345
1 2 3 4 5

   ".,.1!:1[1
12345
1 2 3 4 5

Si vous lisez des chaînes, le moyen le plus court pour obtenir une liste encadrée de chaînes distinctes est d'utiliser ;:. Cela fonctionne mieux pour les chaînes séparées par des espaces:

   ;:1!:1[1
hello world
┌─────┬─────┐
│hello│world│
└─────┴─────┘

Utiliser l'itération pour calculer des séquences

En règle générale, la résolution d'un défi de séquence OEIS nécessite l'utilisation d'une des formules données sur sa page. Certains d'entre eux s'adaptent bien à J, et d'autres moins. Les formules récursives sont simples, cependant, l'itération peut ne pas être simple. Un modèle que j'ai commencé à utiliser est

(s(]f)^:[~]) n
          ]  Gets n
 s           The first value in the sequence
         ~   Commute the argument order, n is LHS and s is RHS
        [    Gets n
      ^:     Nest n times with an initial argument s
  (]f)         Compute f s
             Returns (f^n) s

où sest la première valeur de la séquence, fest un verbe qui calculera le terme suivant étant donné le terme précédent, et nest l'index de base zéro du terme que vous souhaitez calculer. Cette méthode repose sur le fait que lors du calcul de la puissance d'une dyade, le LHS est lié à la dyade pour former une nouvelle monade, et cette monade est imbriquée sur la valeur initiale. La dyade donnée à l'adverbe de puissance est un crochet où (]f)est donné l'indice nsur le LHS et la valeur d'un terme dans la séquence s. Le crochet s'appliquera fen stant que monade, puis ignorera npour renvoyer le résultat de f s.

Bibliothèque standard

Parfois, vous trouverez peut-être que J prendra en charge un verbe dans sa bibliothèque standard . Par exemple, la plupart des opérations entières au niveau du bit sont liées à des noms plus courts que l'utilisation de l'appel primitif.

AND =: (17 b.) NB. it is actually '$:/ :(17 b.)'

Des fonctions intégrées de date et d'heure sont également disponibles.

Gammes

Si vous avez un ensemble de valeurs [a, b, c]et que vous souhaitez former une plage basée sur leur produit [0, 1, 2, ..., a*b*c-1], l'approche typique serait de trouver leur produit, puis de former une plage qui pourrait [:i.*/coûter 6 octets. Une manière plus courte est ,@i.de 4 octets car i.peut former des tableaux multidimensionnels tout en comptant toujours, et l'aplatir produira une plage équivalente.

Impression en continu

Une manière tacite d'imprimer une valeur et de continuer à l'utiliser sans boucle explicite est ([echo)pour un cas monadique. echoest un verbe de la bibliothèque standard qui imprime son contenu stdoutdans le même format que celui utilisé dans l'interpréteur. Le crochet passe ensuite la même valeur d'entrée à l'aide du [verbe gauche .

Base 10 chiffres d'un entier

La manière standard d'acquérir les 10 chiffres de base d'un entier est celle 10#.inv]qui coûte 8 octets de trop! Une alternative consiste à le convertir en une chaîne et à l'analyser au rang 0, "."0@":ce qui économise un octet, mais une méthode encore meilleure consiste à ,.&.":enregistrer un autre octet, ce qui rend le coût final 6 octets au lieu de 8.

Envisagez d'utiliser une définition explicite au lieu d'écrire un verbe tacite; sûr 3 :'et 'coûte 5 octets, mais vous pouvez économiser beaucoup @, @:et de [:cette façon.

Quelques astuces (assez) courantes que j'ai vues

Je partage quelques choses qui m'ont été utiles. Fondamentalement, ce sont tous des conseils que j'ai reçus moi-même, mais je n'ai pas de crédits pour la plupart.

Somme d'un tableau de rang un

Au lieu d'utiliser +/@:(FGH)use (1#.FGH). Cela signifie une dégradation de la base 1, ce qui signifie en fait la somme d'un tableau. Bien qu'il soit plus long que +/cela, il ne nécessite pas de bouchon ou de composition, ce qui le rend souvent beaucoup plus court que l'utilisation +/.

Compter les dernières vérités

Si vous avez une liste booléenne et que vous souhaitez compter le nombre de vérités de fin, utilisez #.~. Voyez ici . La réponse APL explique bien comment cela fonctionne. Certes, cela ne m'a été utile que deux fois, mais j'ai pensé que je le partagerais de toute façon.

En dessous de (&.)

Pas une astuce spécifique, mais juste une suggestion générale: l'adverbe &.-under conduit souvent à des solutions élégantes et (surtout) courtes. Gardez cela à l'esprit lorsque vous jouez au golf.

Souvent, il est utile pour les défis de conversion binaire et autres bases, par exemple ce code qui supprime le bit le plus significatif d'un nombre: }.&.#:(convertir en liste de chiffres binaires, supprimer le premier chiffre, puis annuler la conversion en liste de chiffres binaires et convertir retour à la décimale). La solution simple est deux octets: #.@}.@#:.

Sous est également utile pour les défis où vous devez travailler avec des chiffres décimaux, car vous pouvez utiliser u&.":. Par exemple, les miles à court de manière à diviser donne à DÉCIMALES utilisations sous: ,.&.":.

Un dernier exemple est de trouver l'ampleur d'un vecteur :, +/&.:*:notez que vous devez collecter tous les résultats de *:-square avec &.:-under puisque *:-square est de rang zéro.

Des moyens plus courts de jouer avec les rangs

Parfois, vous aurez du code comme <"0 i.3 3, où vous souhaitez appliquer un verbe vau rang r. Cependant, si vous utilisez un nom (comme 0), vous devrez souvent inclure un espace. Pour éviter cela, vous pouvez utiliser un autre verbe ude rang équivalent et utiliser à la u"vplace. Par exemple, puisque +a rang 0 0 0, nous pouvons utiliser à la <"+place de <"0.

Voici un tableau de tous les verbes et de leurs rangs (obtenus en utilisant v b. 0):

0 0 0     > + * - % ^ | ! ? <. <: >. >: +. +: *. *: %: ^. j. o. q: r.
0 _ _     -. -: E. i: p:
1 0 1     p..
1 0 _     { A.
1 1 0     p.
1 1 1     #.
1 1 _     C.
1 _ _     ;: ". i. I.
2 _ 2     %.
_ 0 0     = < ~. ~: {: }: ?. L.
_ 1 0     #:
_ 1 _     $ # |. |: {. }. ": {::
_ _ _     , ; [ ] _: $. $: ,. ,: /: \: [: e. s: u: x: 0:

Pour utiliser ce tableau, trouvez le rang souhaité rsur le côté gauche, puis choisissez un verbe approprié vdans le côté droit. Par exemple, si j'ai besoin de vectoriser un verbe ven profondeur 2 _ 2, je trouve ce rang à gauche et je choisis %.à droite. Ensuite, j'utilise v"%.au lieu de v"2 _ 2.

strings bibliothèque: conseils de golf

La bibliothèque de chaînes est extrêmement utile pour faire quoi que ce soit avec la manipulation de chaînes. Bien sûr, cela prend include'strings'(ce qui est très coûteux, compte tenu de J), ​​mais vous pouvez parfois en retirer les avantages.

stringreplace

Vous trouvez-vous en utilisant le remplacement de chaîne? Observez que A stringreplace Bc'est la même chose que B rplc A.

En fait, voici comment rplcest mis en œuvre:

   rplc
 stringreplace~

cuts

Le verbe cutsfournit ainsi:

couper y en x (conjonction)
chaîne (verbe coupe n) texte
  n = _1 jusqu'à mais sans inclure la chaîne
  n = 1 jusqu'à et y compris la chaîne
  n = _2 après mais sans inclure la chaîne
  n = 2 après et y compris la chaîne

Donc, c'est vraiment trancher une chaîne.

Obtenir des nombres de 0 à 4

S'il y a une restriction sur l'utilisation de chiffres dans votre code:

0 %_ : un divisé par l'infini.
1 #_ : combien d'infinis?
2 #_ _ : deux infinis.
3 verb : il y a un intégré.
4 dyad : un autre intégré.

Obtenir des nombres de 10 à 35

Base-inifinity littéraux: 11 : _bb, 26 : _bqetc.

Programmation tacite

Les bases

Verbe dyadique

x (F G H) y == (x F y) G (x H y)
x (F G) y == x F (G y)
x ([: G H) y == G (x H y)  NB. G is called monadically

NB. Verbs are grouped from the right by units of 3.
NB. For the following, think like G, I, K are replaced by the results of (x G y) etc.
NB. and then the sentence is run as usual.
x (F G H I J K) y == x (F (G H (I J K))) y
                  == x F ((x G y) H ((x I y) J (x K y)))

NB. Using conjunctions for dyadic verb
x F@G y == F (x G y)  NB. Atop; Same as x ([: F G) y; Consider as golfing alternatives
x F&G y == (G x) F (G y)  NB. Compose; G is applied monadically to both arguments

Verbe monadique

(F G H) y == (F y) G (H y)
(G H) y == y G (H y)  NB. Note that this is different from APL
([: G H) y == G (H y)
(F G H I J K) y == (F (G H (I J K))) y
                == y F ((G y) H ((I y) J (K y)))
F@G y == F (G y)

Misc

x&F y == x F y
F&y x == x F y
y F~ x == x F y
F~ y == y F y

Des trucs

(F x) G (H y)

Solution Tacite: (G~F)~H; selon les verbes réels, pensez à réorganiser les arguments gauche et droit à supprimer ~.

x ((G~F)~H) y
x (G~F)~ (H y)
(H y) (G~F) x
(H y) G~ (F x)
(F x) G (H y)

Remplacements monadic-dyadiques

>:y == 1+y
<:y == 1-~y or _1+y
+:y == 2*y
-.y == 1-y
-:y == 2%~y
*:y == 2^~y
#.y == 2#.y
#.inv y == 2#.inv y  NB. #: doesn't work this way
{.y == 0{y
{:y == _1{y
}.y == 1}.y
+/y == 1#.y

& est votre ami, utilisez-le à bon escient

vest un verbe, nest un substantif xet ysont des arguments gauche et droit, respectivement.

Monade &: Introduire à l' ~intérieur de la chaîne adverbe / conjonction

Une chaîne adverbe / conjonction évalue à partir de la gauche. Donc, quelque chose comme ça _2&+/\&.>ne fonctionnera pas parce qu'il analyse comme (_2&+)/\&.>nous le voulons _2&(+/\)&.>. Dans ce cas, l'échange de la gauche / droite de +/\peut enregistrer un octet, comme dans +/\~&_2&.>car celui-ci est analysé comme ((+/\)~)&_2&.>. Pour voir pourquoi cela fonctionne:

+/\~&_2 y
is equivalent to
y +/\~ _2
is equivalent to
_2 +/\ y
is equivalent to
_2&(+/\) y

Dyad &: répéter xfois

Saviez-vous que si vous donnez un argument de gauche xà &, la fonction l'applique xfoisy ? Plusieurs défis vous demandent de faire certains xtemps de fonctionnement . Il est principalement réalisable de deux manières:

• Utiliser l'opérateur de puissance ^:sans l'opérande droit

Si l'opération est v, v^:devient alors un train d'adverbe qui, lorsqu'on lui donne un opérande gauche, devient un verbe monadique. Il en vest ainsi appliqué y, xfois.

x(v^:)y
is equivalent to
(v^:x)y

• Utilisez le dyadique &comme conjonction la plus externe

Pour l'utiliser, vous devez identifier une constante net un verbe dyadique u, de sorte que soit n u you y u nsoit équivalent à v. Ensuite, vous pouvez écrire n&uou u&nrésoudre la tâche entière. Cette forme est plus efficace lorsque le choix de la constante est évident, par exemple 3 in 3 u:(convertir les caractères en valeurs ASCII).

En outre, u&nest légèrement préférable à n&ulorsque la structure la plus externe de uest une conjonction ou un adverbe (dans ce cas , vous n&udevriez le faire n&(u); vous pouvez le faire à la u~&nplace).

Notez que vous pouvez placer le dyadique &n'importe où dans un train pour obtenir la répétition d'une fonction arbitraire en argument arbitraire, dans le sens similaire à dynamique ^:.