Teilweise Listen und Arrays

14

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 , 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.

Stewie Griffin
quelle
Um es klar auszudrücken, werde ich vermuten, dass dies gegen den Geist der Herausforderung verstößt. Ist es jedoch zulässig, den Code der nächsten Aufgabe mit einer Umleitung zu STDERR zu starten, >2;sodass der Code der vorherigen Aufgabe im Wesentlichen als No-Op dargestellt wird?
AdmBorkBork
1
@AdmBorkBork, es gibt keinen "Geist der Herausforderung" bei PPCG: P Ja, das ist in Ordnung .
Stewie Griffin
Muss die Multiplikationstabelle gut gepolstert sein?
HyperNeutrino
1
@HyperNeutrino, nein.
Stewie Griffin
Wenn Sie "positive ganze Zahl" sagen, meinen Sie 0<n<moder 0<=n<m?
Value Ink

Antworten:

6

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.

Dennis
quelle
5

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
Emigna
quelle
3

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
Luis Mendo
quelle
3

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.

Genisis
quelle
2

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.

Genosse SparklePony
quelle
Können Sie anonyme Funktionen nicht nutzen oder sind Lambdas nicht wirklich kürzer? (nach meiner Zählung scheinen sie es zu sein)
Cole
Ist dies für Python-Antworten im Allgemeinen akzeptabel? Der Code für Aufgabe 2 ist beispielsweise kein vollständiges Programm mit Ein- und Ausgängen, und es ist auch keine Funktion oder Funktionsdefinition.
Genisis
@Cole Ich musste nicht anonyme Funktionen verwenden, damit ich sie im späteren Code verwenden konnte.
Genosse SparklePony
@ngenisis Ich denke, es ist in Ordnung, weil das OP sagte, der Code für Aufgabe 2 muss mit dem Code für Aufgabe 1 beginnen, und der Code für Aufgabe 2 def s(n,m):return [[w+i for w in r(n,m)] for i in a(0,m+1)]ist eine vollständige Funktion, wenn der Code für Aufgabe 1 definiert ist.
Genosse SparklePony
Sie können a=lambda n,m:...für jede Ihrer Funktionsdefinitionen etwas Ähnliches tun . Anonyme Funktionen sind in Python immer kürzer
Math Junkie
2

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.

user63956
quelle
1

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.

AdmBorkBork
quelle
1

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 .

Neil JS Grump
quelle
0

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
Wert Tinte
quelle