Dans ce défi, vous obtiendrez quatre tâches différentes mais quelque peu liées qui doivent être résolues de manière spécifique. Tout d'abord, je vais expliquer les tâches, puis suit une explication de la façon dont vous devez le résoudre.

Votre code doit pour les quatre tâches prendre deux entiers positifs en entrée:, n,moù n<m. Toutes les tâches doivent être résolues dans la même langue. L'orientation des matrices est facultative (n sur m peut être interprété comme "n lignes, m colonnes" ou "n colonnes, m lignes").

Tache 1:

Créer (et sortie / impression) un vecteur / liste constituée des éléments suivants: n, n+1 ... m-1, m. Donc, pour n=4, m=9, vous devriez sortie: 4,5,6,7,8,9.

Tâche 2:

Créez (et éditez / imprimez) une matrice / tableau / liste de listes (ou équivalent) ressemblant à ceci:

n,   n+1, ... m-1, m
n+1, n+2, ... m-1, m+1
...
n+m, n+m+1, ... 2*m-1, 2*m

Car n=4, m=9vous devez sortir:

4, 5, 6, 7, 8, 9
5, 6, 7, 8, 9, 10
...
13, 14, 15, 16, 17, 18

Tâche 3:

Créez (et imprimez / imprimez) une table de multiplication n par m (sur n'importe quel format approprié). Exemple pour n=4, m=9:

1   2   3  4
2   4   6  8
3   6   9  12
4   8  12  16
5  10  15  20
6  12  18  24
7  14  21  28
8  16  24  32
9  18  27  36

Tâche 4:

Produire / imprimer un vecteur / liste composé des éléments du tableau de multiplication de la tâche 3, triés par ordre croissant, en conservant les valeurs en double. Pour n=4, m=9, vous devriez sortie: 1, 2, 2, 3, 3, 4, 4, 4, 5, 6, 6, 6, 7, 8, 8, 8, 9, 9, 10, 12, 12, 12, 14, 15, 16, 16, 18, 18, 20, 21, 24, 24, 27, 28, 32, 36.

Le défi:

Maintenant, toutes les tâches ci-dessus sont assez triviales. Le vrai défi ici est que le code de la tâche 2 doit commencer par le code de la tâche 1, le code de la tâche 3 doit commencer par le code de la tâche 2 et le code de la tâche 4 doit commencer par le code de la tâche 3.

Pour être plus clair:

Supposons que le code de la tâche 1 soit (fonctionne en octave):

@(n,m)(n:m)

Ensuite, votre code pour la tâche 2 pourrait être (fonctionne dans Octave):

@(n,m)(n:m)+(0:m)'

Le code de la tâche Tâche 3 doit être (ne fonctionne pas dans Octave):

@(n,m)(n:m)+(0:m)'"Code_for_task_3"

Et enfin, le code de la tâche 4 doit être (ne fonctionne pas dans Octave):

@(n,m)(n:m)+(0:m)'"Code_for_task_3""Code_for_task_4"

Il s'agit de code-golf , donc la soumission avec le code le plus court pour la tâche 4 dans chaque langue gagne. Comme toujours: les explications sont fortement encouragées.

Gelée , 12 octets

Tache 1

r

Essayez-le en ligne!

Tâche 2

r+þ0r$}

Essayez-le en ligne!

Tâche 3

r+þ0r$}
×þ

Essayez-le en ligne!

Tâche 4

r+þ0r$}
×þFṢ

Essayez-le en ligne!

Comment ça fonctionne

Tache 1

rest l' atome de la gamme dyadique et fait exactement ce que la tâche demande.

Tâche 2

Une chaîne dyadique qui commence par trois maillons dyadiques est une fourchette ; les liens les plus extérieurs sont évalués en premier, puis le lien du milieu est appelé avec les résultats des deux côtés comme arguments.

• rse comporte comme auparavant, donnant [n,…, m] .

• 0r$} est un lien rapide (ou un lien rapide, si vous voulez).

  La $chaîne rapide (chaîne monadich) consomme les maillons 0(rendement 0 ) et r(plage dyadique) et les transforme en chaîne monadique. Lorsqu'il est appelé avec l'argument k , cela donnera [0,…, k] .

  Le quick }(argument de droite) prend le lien rapide créé par $et le transforme en un lien dyadique qui appelle 0r$avec 0r$}le bon argument de.

  0r$}sera appelé avec l'argument gauche n et l'argument droit m , il 0r$est donc associé à l'argument m et donne [0,…, m] .

• +þest un autre lien rapide. þ(table) appellera +(addition) pour chaque élément de son argument de gauche et tout élément de son argument de droite, en regroupant les résultats de chaque argument de droite sur une seule ligne.

  +þsera appelé avec l'argument gauche [n,…, m] et l'argument droit [0,…, m] , donnant la table désirée.

Tâche 3

Chaque ligne d'un programme Jelly définit un lien différent. Le dernier est le lien principal et, comme la mainfonction de C , est le seul lien qui est exécuté par défaut. Les liens restants peuvent être appelés à partir du lien principal, mais nous ne le ferons pas ici.

Comme précédemment, þ(table) appellera ×(addition) pour chaque élément de son argument de gauche et tout élément de son argument de droite, en regroupant les résultats de chaque argument de droite sur une seule ligne.

Comme les deux arguments ×þsont des entiers, þles convertit en plages, transformant les arguments n et m en [1,…, n] et [1,…, m] .

Tâche 4

×þfonctionne comme avant. Les liens suivants sont monadiques, ce qui en fait des sommets , c'est-à-dire qu'ils sont appliqués par-dessus les précédents.

Après l'exécution ×þ, Faplatit le tableau 2D résultant et Ṣtrie le tableau 1D résultant.

05AB1E , 18 17 octets

Tache 1

Ÿ

Essayez-le en ligne

Tâche 2

Ÿ²FD>})

Essayez-le en ligne

Tâche 3

Ÿ²FD>})v¹LN*})¦

Essayez-le en ligne

Tâche 4

Ÿ²FD>})v¹LN*})¦˜{

Essayez-le en ligne

Explications

Tache 1

Ÿ     # range[n ... m]

Tâche 2

Ÿ        # range[n ... m]
 ²F      # m times do:
   D     # duplicate
    >    # increment
     }   # end loop
      )  # wrap in list

Tâche 3

v          # for each list in result of Task 2 do
 ¹L        # push range[1 ... n]
   N*      # multiply by index
     }     # end loop
      )    # wrap in list
       ¦   # discard first element

Tâche 4

˜          # flatten the result from Task 3
 {         # sort

MATL , 18 17 octets

Tache 1

&:

Essayez-le en ligne!

Tâche 2

&:O2G:h!+

Essayez-le en ligne!

Tâche 3

&:O2G:h!+:7M!*

Essayez-le en ligne!

Tâche 4

&:O2G:h!+:7M!*1eS

Essayez-le en ligne!

Explication

Tache 1

&:    % Binary range [n n+1 ... m] from implicit inputs n, m

Tâche 2

      % ... Stack contains [n n+1 ... m]
O     % Push 0
2G    % Push second input, m
:     % Unary range: gives [1 2 ... m]
h     % Concatenate horizontally: gives [0 1 2 ... m]
!     % Transpose into a column vector
+     % Add with broadcast

Tâche 3

      % ... Stack contains matrix from task 2
:     % Unary range. For matrix input it uses its (1,1) entry. So this gives [1 2 ... n]
7M    % Push [1 2 ... m] again
!     % Transpose into a column vector
*     % Multiply with broadcast

Tâche 4

      % ... Stack contains matrix from task 3
1e    % Linearize into a row vector
S     % Sort

Mathematica, 84 77 octets

Edit: Merci à Martin Ender pour avoir économisé 7 octets.

Tache 1:

{n,m}n~Range~m

Pur Functionavec des arguments net mqui produit n~Range~m, la forme infixe de Range[n,m].

Tâche 2:

{n,m}n~Range~m~Table~(m+1)//0~Range~m+#&

n~Range~m~Table~(m+1)crée un tableau 2D avec des m+1lignes, où chaque ligne est la sortie de la tâche précédente. Ensuite, l' //0~Range~m+#&application postfixe de la fonction 0~Range~m+#&s'ajoute effectivement 0à la première ligne, 1à la deuxième ligne, et ainsi de suite jusqu'à mlam+1 -ème ligne.

Tâche 3:

{n,m}n~Range~m~Table~(m+1)//0~Range~m+#&//1##&~Array~{n,m}&

Cela applique simplement la fonction constante 1##&~Array~{n,m}&à la sortie de la tâche précédente.

Tâche 4:

{n,m}n~Range~m~Table~(m+1)//0~Range~m+#&//1##&~Array~{n,m}&//Flatten//Sort

Flattens et Sorts la table de multiplication.

Python, 183 octets

Tâche 1, 29 octets

r=range
a=lambda n,m:r(n,m+1)

Essayez-le en ligne!

Tâche 2, 84 octets

r=range
a=lambda n,m:r(n,m+1)
s=lambda n,m:[[w+i for w in r(n,m)] for i in a(0,m+1)]

Essayez-le en ligne!

Tâche 3, 137 octets

r=range
a=lambda n,m:r(n,m+1)
s=lambda n,m:[[w+i for w in r(n,m)] for i in a(0,m+1)]
d=lambda n,m:[[w*i for w in a(1,n)] for i in a(1,m)]

Essayez-le en ligne!

Tâche 4, 183 167 octets

r=range
a=lambda n,m:r(n,m+1)
s=lambda n,m:[[w+i for w in r(n,m)] for i in a(0,m+1)]
d=lambda n,m:[[w*i for w in a(1,n)] for i in a(1,m)]
f=lambda(z):sorted(sum(z,[]))

Essayez-le en ligne!

Explication:

Tache 1:

Assez simple, il génère une nà la mliste à l' aide de Python intégré rangefonction.

Tâche 2:

Pour chaque numéro 0à m+1, il ajoute ce numéro à chaque élément d'une liste de nà m.

Tâche 3:

Pour chaque nombre de 1à m, il multiplie ce nombre par chaque nombre dans une liste de 1à n.

Tâche 4:

Cela utilise la sortedfonction intégrée de Python qui trie une liste du plus petit au plus grand. La compréhension de la liste dans la fonction est utilisée pour aplatir la liste. Il crée une liste de chaque élément de chaque élément de la liste qui lui est attribuée par la tâche 3.

• Beaucoup d'octets enregistrés grâce à @math_junkie.
• 16 octets enregistrés grâce à @ThisGuy

Beaucoup d'octets enregistrés grâce à @math_junkie.

PHP 7, 200 octets

Utilise le tampon de sortie pour effacer la sortie précédente.

Tache 1

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');

Enregistre le code $spour le réutiliser plus tard. le$v variable concerne la dernière tâche.

Tâche 2

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');for(;++$i<=$m;)eval($s);

Imprime les lignes restantes.

Tâche 3

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');for(;++$i<=$m;)eval($s);for(($c=ob_clean)();++$j<=$m;print"
")for(;++$$j<=$n;sort($v))echo$v[]=$j*$$j,' ';

Efface le tampon de sortie et imprime la table de multiplication, en enregistrant les nombres dans $v.

Tâche 4

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');for(;++$i<=$m;)eval($s);for(($c=ob_clean)();++$j<=$m;print"
")for(;++$$j<=$n;sort($v))echo$v[]=$j*$$j,' ';$c();eval($s);

Efface à nouveau le tampon de sortie et imprime $v.

PowerShell , 126 octets

Tache 1

param($n,$m)$n..$m

Essayez-le en ligne!

Utilise l' ..opérateur de plage intégré. Le comportement par défaut pour l'impliciteWrite-Output insère une nouvelle ligne entre les éléments, c'est pourquoi la sortie s'affiche comme une nouvelle ligne séparée.

Tâche 2

param($n,$m)$n..$m>2;0..$m|%{$i=$_;($n..$m|%{$_+$i})-join','}

Essayez-le en ligne!

Vide la première tâche dans STDERR avec >2;, puis boucle de 0à $m, chaque assistant de réglage d'itération $iavant de boucler à nouveau de $nvers $met d'incrémenter chaque nombre de $i. Ce sont-join édités avec des virgules, sinon ce serait une sortie gigantesque longue et ambiguë d'un élément par ligne.

Tâche 3

param($n,$m)$n..$m>2;0..$m|%{$i=$_;($n..$m|%{$_+$i})-join','}>2;(1..$m|%{$i=$_;(1..$n|%{$_*$i})-join' '})

Essayez-le en ligne!

Même chose >2;pour vider le précédent dans STDERR. Ensuite, nous faisons simplement une double boucle de 1à $mpuis 1à $n, en définissant helper le $ilong du chemin, multiplions les valeurs et -joinavec un espace pour le rendre tabulaire. Notez les parens d'encapsulation - ils entreront en jeu lors de la prochaine tâche - mais ici, ils s'assurent simplement que la sortie est placée sur le pipeline (ce qu'elle serait déjà, donc ils sont redondants).

Tâche 4

param($n,$m)$n..$m>2;0..$m|%{$i=$_;($n..$m|%{$_+$i})-join','}>2;(1..$m|%{$i=$_;(1..$n|%{$_*$i})-join' '})-split' '|%{+$_}|sort

Essayez-le en ligne!

Ah! Enfin une certaine redondance. Étant donné que la tâche précédente a des parens, nous pouvons clouer sur l' -splitespace blanc sans souci, convertir chacun en un entier |%{+$_}, puis |sort. La sortie est à nouveau séparée de la nouvelle ligne.

Je pense qu'il existe des moyens de mieux tirer parti de la redondance entre les tâches - tout en jouant au golf.

ES2016-ish, 401 384 caractères

Voici un premier essai. Je suis sûr que cela pourrait être un peu condensé, mais c'est assez court. Fonctions flèches FTW! (J'adore ces déclarations de retour implicites.) Nouveau et amélioré avec des chaînes de modèle!

Tache 1

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `)

Appelez z(n,m)la sortie du journal. (Je suis aliasing console.log pour jouer au golf plus tard.)

Tâche 2

Le deuxième verset ... développe le premier.

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `),p,o,g=(n,m)=>{p=n,o=m;return [...a(m+1).keys()].map((d)=>f(d+p,d+o))},y=(n,m)=>l(g(n,m).join`\n`

Maintenant, appelez y(n,m). Jolie, non?

Tâche 3

Vous devez contourner la plupart des fonctionnalités existantes <sadface />.

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `),p,o,g=(n,m)=>{p=n,o=m;return [...a(m+1).keys()].map((d)=>f(d+p,d+o))},y=(n,m)=>l(g(n,m).join`\n`,h=(n,m)=>[...a(m).keys()].map((d)=>(d+1)*n).join`\t`,i=(n,m)=>[...a(n).keys()].map((d)=>h((d+1),m)),v=(n,m)=>i(n,m).join`\n`

Maintenant, le nom de la méthode est v. Appelez-le de la même manière.

Tâche 4

Et maintenant, nous pouvons à nouveau réutiliser.

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `),p,o,g=(n,m)=>{p=n,o=m;return [...a(m+1).keys()].map((d)=>f(d+p,d+o))},y=(n,m)=>l(g(n,m).join`\n`,h=(n,m)=>[...a(m).keys()].map((d)=>(d+1)*n).join`\t`,i=(n,m)=>[...a(n).keys()].map((d)=>h((d+1),m)),v=(n,m)=>i(n,m).join`\n`,t=(n,m)=>l(v(n,m).match(/\d+/g).sort((a,b)=>+a>+b||+(a===b)*2-1).join(`, `)

J'ai dû sauter upour ma méthode, donc c'est t. Bummed que je devais mettre dans cette fonction de tri, car les String.matchvaleurs retournées sous forme de ... chaînes.

Rubis, 121 103 octets

Tout dans Ruby est truthy à l' exception nilet false, ce qui signifie que les tâches peuvent être configurées pour ignorer l' entrée précédente avec rien mais bien placé and/ &&.

Tache 1

Essayez-le en ligne!

n,m=$*.map &:to_i
p [*n..m]

Tâche 2

Essayez-le en ligne!

n,m=$*.map &:to_i
p [*n..m]&&(0..m).map{|i|[*n+i..m+i]}

Tâche 3

Essayez-le en ligne!

n,m=$*.map &:to_i
p [*n..m]&&(0..m).map{|i|[*n+i..m+i]}&&(1..m).map{|i|(1..n).map{|j|i*j}}

Tâche 4

Essayez-le en ligne!

n,m=$*.map &:to_i
p [*n..m]&&(0..m).map{|i|[*n+i..m+i]}&&(1..m).map{|i|(1..n).map{|j|i*j}}.flatten.sort