In dieser Herausforderung erhalten Sie vier verschiedene, aber etwas verwandte Aufgaben, die auf eine bestimmte Art und Weise gelöst werden müssen. Zuerst erkläre ich die Aufgaben, dann folgt eine Erklärung, wie Sie sie lösen müssen.

Ihr Code sollte für alle vier Aufgaben zwei positive Ganzzahlen als Eingabe verwenden: n,m wobei n<m. Alle Aufgaben müssen in derselben Sprache gelöst werden. Die Ausrichtung der Matrizen ist optional (n-mal-m kann als "n Zeilen, m Spalten" oder "n Spalten, m Zeilen" interpretiert werden).

Aufgabe 1:

Erstellen (und Ausgabe / Druck) einen Vektor / Liste bestehend aus den Elementen: n, n+1 ... m-1, m. Für n=4, m=9sollten Sie also Folgendes ausgeben:4,5,6,7,8,9 .

Schritt 2:

Erstellen (und ausgeben / drucken) einer Matrix / eines Arrays / einer Liste von Listen (oder einer entsprechenden Liste) mit folgendem Aussehen:

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

Denn n=4, m=9Sie sollten ausgeben:

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

Schritt 3:

Erstellen (und ausgeben / drucken) einer n-mal-m-Multiplikationstabelle (in einem beliebigen geeigneten Format). Beispiel für 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

Schritt 4:

Ausgeben / Drucken eines Vektors / einer Liste, die aus den Elementen in der Multiplikationstabelle aus Aufgabe 3 besteht, sortiert in aufsteigender Reihenfolge, wobei doppelte Werte beibehalten werden. Für n=4, m=9, sollten Sie die Ausgabe: 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.

Die Herausforderung:

Jetzt sind alle oben genannten Aufgaben ziemlich trivial. Die eigentliche Herausforderung hierbei ist, dass der Code für Aufgabe 2 mit dem Code für Aufgabe 1 beginnen muss, der Code für Aufgabe 3 mit dem Code für Aufgabe 2 beginnen muss und der Code für Aufgabe 4 mit dem Code für Aufgabe 3 beginnen muss.

Um es klarer zu machen:

Angenommen, der Code für Task 1 lautet (funktioniert in Octave):

@(n,m)(n:m)

Dann könnte Ihr Code für Aufgabe 2 lauten (funktioniert in Octave):

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

Der Code für die Aufgabe Aufgabe 3 muss sein (funktioniert nicht in Octave):

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

Und schließlich muss der Code für Task 4 sein (funktioniert nicht in Octave):

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

Dies ist Code-Golf , daher gewinnt die Einsendung mit dem kürzesten Code für Aufgabe 4 in jeder Sprache. Wie immer: Erklärungen sind ausdrücklich erwünscht.

Gelee , 12 Bytes

Aufgabe 1

r

Probieren Sie es online!

Aufgabe 2

r+þ0r$}

Probieren Sie es online!

Aufgabe 3

r+þ0r$}
×þ

Probieren Sie es online!

Aufgabe 4

r+þ0r$}
×þFṢ

Probieren Sie es online!

Wie es funktioniert

Aufgabe 1

rist das dyadische Bereichsatom und macht genau das, was die Aufgabe verlangt.

Aufgabe 2

Eine dyadische Kette, die mit drei dyadischen Gliedern beginnt, ist eine Gabel ; Die äußersten Links werden zuerst ausgewertet, dann wird der mittlere Link mit den Ergebnissen zu beiden Seiten als Argumente aufgerufen.

• rverhält sich wie zuvor und ergibt [n,…, m] .

• 0r$} ist ein Quicklink (oder Quickquicklink, wenn Sie so wollen).

  Die schnelle $(Monadich-Kette) verbraucht die Glieder 0(Ausbeute 0 ) und r(dyadischer Bereich) und verwandelt sie in eine monadische Kette. Wenn mit dem Argument k aufgerufen wird, ergibt dies [0,…, k] .

  Das schnelle }(rechtes Argument) führt den Quicklink erstellt von $und verwandelt es in einen Dyade Link , dass Anrufe 0r$mit 0r$}‚s rechten Argumente.

  0r$}wird mit linkem Argument n und rechtem Argument aufgerufen m , so 0r$wird mit dem Argument Ursprungserzeugnisse m und Ausbeuten [0, ..., m] .

• +þist ein weiterer Quicklink. þ(table) ruft +für jedes Element in seinem linken Argument und für jedes Element in seinem rechten Argument (addition) auf und gruppiert die Ergebnisse für jedes rechte Argument in einer einzelnen Zeile.

  +þwird mit linkem Argument [n,…, m] und rechtem Argument [0,…, m] aufgerufen und ergibt die gewünschte Tabelle.

Aufgabe 3

Jede Zeile in einem Jelly-Programm definiert einen anderen Link. Der letzte Link ist der Hauptlink und wie die mainFunktion von C der einzige Link, der standardmäßig ausgeführt wird. Die restlichen Links können über den Hauptlink aufgerufen werden, aber wir werden dies hier nicht tun.

Wie zuvor þruft (table) ×für jedes Element in seinem linken Argument und für jedes Element in seinem rechten Argument (addition) auf und gruppiert die Ergebnisse für jedes rechte Argument in einer einzelnen Zeile.

Da beide Argumente ×þGanzzahlen sind, werden þsie in Bereiche umgewandelt, wobei die Argumente n und m in [1,…, n] und [1,…, m] umgewandelt werden .

Aufgabe 4

×þfunktioniert wie bisher. Die folgenden Links sind monadisch und machen sie übergeordnet bezeichnet , das heißt, sie oben auf den vorherigen angewendet werden.

Nach der Ausführung ×þ, Fflacht den resultierenden 2D - Array, und Ṣsortiert den resultierenden 1D - Array.

05AB1E , 18 17 Bytes

Aufgabe 1

Ÿ

Probieren Sie es online aus

Aufgabe 2

Ÿ²FD>})

Probieren Sie es online aus

Aufgabe 3

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

Probieren Sie es online aus

Aufgabe 4

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

Probieren Sie es online aus

Erklärungen

Aufgabe 1

Ÿ     # range[n ... m]

Aufgabe 2

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

Aufgabe 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

Aufgabe 4

˜          # flatten the result from Task 3
 {         # sort

MATL , 18 17 Bytes

Aufgabe 1

&:

Probieren Sie es online!

Aufgabe 2

&:O2G:h!+

Probieren Sie es online!

Aufgabe 3

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

Probieren Sie es online!

Aufgabe 4

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

Probieren Sie es online!

Erläuterung

Aufgabe 1

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

Aufgabe 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

Aufgabe 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

Aufgabe 4

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

Mathematica, 84.77 Bytes

Edit: Danke an Martin Ender für das Speichern von 7 Bytes.

Aufgabe 1:

{n,m}n~Range~m

Rein Functionmit Argumenten nund mwelche Ausgaben n~Range~m, die Infixform von Range[n,m].

Schritt 2:

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

n~Range~m~Table~(m+1)Erstellt ein 2D-Array mit m+1Zeilen, wobei jede Zeile die Ausgabe der vorherigen Aufgabe ist. Dann //0~Range~m+#&ist Postfix Anwendung der Funktion , 0~Range~m+#&die wirksam fügt 0zu der ersten Reihe 1zu der zweiten Reihe und so weiter bis zu mder m+1-ten Zeile.

Schritt 3:

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

Dies wendet nur die konstante Funktion 1##&~Array~{n,m}&auf die Ausgabe der vorherigen Aufgabe an.

Schritt 4:

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

Flattens und Sorts die Multiplikationstabelle.

Python, 183 Bytes

Aufgabe 1, 29 Bytes

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

Probieren Sie es online!

Aufgabe 2, 84 Bytes

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)]

Probieren Sie es online!

Aufgabe 3, 137 Bytes

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)]

Probieren Sie es online!

Task 4, 183 167 Bytes

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,[]))

Probieren Sie es online!

Erläuterung:

Aufgabe 1:

Einfach genug, erzeugt er eine nauf der mListe mit Python-interne rangeFunktion.

Schritt 2:

Für jede Nummer 0zu m+1wird diese Nummer zu jedem Element einer Liste von nbis hinzugefügt m.

Schritt 3:

Für jede Zahl von 1bis mwird diese Zahl mit jeder Zahl in einer Liste von 1bis multipliziert n.

Schritt 4:

Hierbei wird die in Python integrierte sortedFunktion verwendet, mit der eine Liste von der niedrigsten zur höchsten sortiert wird. Das Listenverständnis in der Funktion wird verwendet, um die Liste zu verflachen. Es wird eine Liste jedes Elements in jedem Element der Liste erstellt, die ihm von Aufgabe 3 zugewiesen wurde.

• Sehr viele Bytes dank @math_junkie gespeichert.
• 16 Bytes dank @ThisGuy gespeichert

Sehr viele Bytes dank @math_junkie gespeichert.

PHP 7, 200 Bytes

Verwendet den Ausgabepuffer, um die vorherige Ausgabe zu löschen.

Aufgabe 1

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

Speichert den Code in $s, um ihn später wiederzuverwenden. Das$v Variable ist für die letzte Aufgabe.

Aufgabe 2

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

Druckt die restlichen Zeilen.

Aufgabe 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,' ';

Löscht den Ausgabepuffer und druckt die Multiplikationstabelle, wobei die Zahlen in gespeichert werden $v.

Aufgabe 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);

Löscht den Ausgabepuffer erneut und druckt $v.

PowerShell , 126 Byte

Aufgabe 1

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

Probieren Sie es online!

Verwendet den ..eingebauten Bereichsoperator. Das Standardverhalten für implizite Write-OutputElemente fügt einen Zeilenumbruch zwischen die Elemente ein. Daher wird die Ausgabe als Zeilenumbruch getrennt angezeigt.

Aufgabe 2

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

Probieren Sie es online!

Setzt die erste Aufgabe mit STDERR ab und >2;führt dann eine Schleife von 0bis zu $mjedem Iterationseinstellungs-Helfer durch, $ibevor erneut eine Schleife von $nbis erstellt $mund jede Zahl um erhöht wird $i. Diese werden -joinzusammen mit Kommas ausgegeben, da dies sonst eine mehrdeutige, lange Ausgabe mit einem Element pro Zeile wäre.

Aufgabe 3

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

Probieren Sie es online!

Gleiches gilt >2;für STDERR. Dann haben wir einfach ein Doppelklick Schleife von 1bis $mdann 1zu $n, das Setzen von Helfern $iauf dem Weg, multiplizieren Sie die Werte, und -joinmit einem Raum zu machen tabellarisch. Beachten Sie die einkapselnden Parens - sie werden bei der nächsten Aufgabe ins Spiel kommen -, aber hier stellen sie nur sicher, dass die Ausgabe in die Pipeline gestellt wird (die es bereits wäre, also sind sie redundant).

Aufgabe 4

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

Probieren Sie es online!

Aha! Endlich etwas Redundanz. Da die vorherige Aufgabe über Parens verfügt, können wir das -splitOn-Whitespace ohne Bedenken anheften, jedes in eine Ganzzahl umwandeln |%{+$_}und dann |sort. Die Ausgabe ist wieder Newline-getrennt.

Ich denke, es gibt einige Möglichkeiten, die Redundanz zwischen den Aufgaben besser zu nutzen - und dennoch einige Möglichkeiten, Golf zu spielen.

ES2016-ish, 401 384 Zeichen

Hier ist ein erster Versuch. Ich bin sicher, es könnte ein bisschen verkürzt werden, aber es ist ziemlich kurz. Pfeilfunktionen FTW! (Lieben Sie diese impliziten return-Anweisungen.) Neu und verbessert mit Template-Strings!

Aufgabe 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`, `)

Aufruf z(n,m)für die Protokollausgabe. (Ich benenne console.log für späteres Golfen.)

Aufgabe 2

Zweiter Vers ... erweitert den ersten.

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`

Rufen Sie jetzt an y(n,m). Schön, nein?

Aufgabe 3

Müssen den größten Teil der vorhandenen Funktionalität umgehen <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`

Jetzt lautet der Methodenname v. Nenne es genauso.

Aufgabe 4

Und jetzt können wir wieder verwenden.

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(`, `)

Musste ufür meine Methode überspringen , so ist es t. Blöd, dass ich diese Sortierfunktion einsetzen musste, weil die String.matchRückgabewerte als ... Strings vorliegen .

Ruby, 121 103 Bytes

Alles in Ruby ist truthy Ausnahme nilund false, was bedeutet , dass die Aufgaben aufgebaut werden können vorherige Eingabe mit nichts als ein gut platzierter ignorieren and/ &&.

Aufgabe 1

Probieren Sie es online!

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

Aufgabe 2

Probieren Sie es online!

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

Aufgabe 3

Probieren Sie es online!

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}}

Aufgabe 4

Probieren Sie es online!

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