In questa sfida, otterrai quattro attività diverse ma in qualche modo correlate che devono essere risolte in un modo specifico. Prima spiegherò i compiti, quindi seguirò una spiegazione di come devi risolverlo.

Il tuo codice dovrebbe per tutte e quattro le attività assumere due numeri interi positivi come input:, n,mdove n<m. Tutte le attività devono essere risolte nella stessa lingua. L'orientamento delle matrici è facoltativo (n-per-m può essere interpretato come "n righe, m colonne" o "n colonne, m righe").

Compito 1:

Crea (e l'uscita / print) un vettore / lista costituita dagli elementi: n, n+1 ... m-1, m. Così, per n=4, m=9, si dovrebbe uscita: 4,5,6,7,8,9.

Compito 2:

Crea (e stampa / stampa) una matrice / matrice / lista di liste (o equivalente) simile a questa:

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

Per n=4, m=9te dovresti produrre:

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

Compito 3:

Crea (e stampa / stampa) una tabella di moltiplicazione n-per-m (su qualsiasi formato adatto). Esempio per 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

Compito 4:

Stampa / stampa un vettore / elenco costituito dagli elementi nella tabella di moltiplicazione dall'attività 3, ordinati in ordine crescente, mantenendo valori duplicati. Per n=4, m=9, si dovrebbe uscita: 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.

La sfida:

Ora, tutti i compiti sopra sono abbastanza banali. La vera sfida qui è che il codice per l'attività 2 deve iniziare con il codice per l'attività 1, il codice per l'attività 3 deve iniziare con il codice per l'attività 2 e il codice per l'attività 4 deve iniziare con il codice per l'attività 3.

Per rendere più chiaro:

Supponiamo che il codice per Task 1 sia (funziona in Octave):

@(n,m)(n:m)

Quindi il tuo codice per Task 2 potrebbe essere (funziona in Octave):

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

Il codice per l'attività Task 3 deve essere (non funziona in Octave):

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

E infine, il codice per Task 4 deve essere (non funziona in Octave):

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

Questo è code-golf , quindi vince l'invio con il codice più breve per l'attività 4 in ogni lingua. Come sempre: le spiegazioni sono fortemente incoraggiate.

Gelatina , 12 byte

Compito 1

r

Provalo online!

Compito 2

r+þ0r$}

Provalo online!

Compito 3

r+þ0r$}
×þ

Provalo online!

Compito 4

r+þ0r$}
×þFṢ

Provalo online!

Come funziona

Compito 1

rè l' atomo della gamma diadica e fa esattamente ciò che il compito richiede.

Compito 2

Una catena diadica che inizia con tre maglie diadiche è un fork ; i collegamenti più esterni vengono valutati per primi, quindi viene chiamato il collegamento centrale con i risultati su entrambi i lati come argomenti.

• rsi comporta come prima, producendo [n, ..., m] .

• 0r$} è un collegamento rapido (o collegamento rapido, se vuoi).

  La rapida $(catena monadich) consuma le maglie 0(resa 0 ) e r(intervallo diadico) e le trasforma in una catena monadica. Se chiamato con l'argomento k , questo produrrà [0, ..., k] .

  Il rapido }(argomento giusto) prende il collegamento rapido creato da $e lo trasforma in un collegamento diadico che chiama 0r$con 0r$}l'argomento giusto.

  0r$}verrà chiamato con l'argomento sinistro n e l'argomento destro m , quindi 0r$è associato all'argomento m e produce [0,…, m] .

• +þè un altro collegamento rapido. þ(tabella) chiamerà +(aggiunta) per ogni elemento nel suo argomento a sinistra e per ogni elemento nel suo argomento a destra, raggruppando i risultati per ciascun argomento a destra in una singola riga.

  +þverrà chiamato con l'argomento left [n, ..., m] e l'argomento right [0, ..., m] , producendo la tabella desiderata.

Compito 3

Ogni linea in un programma Jelly definisce un collegamento diverso. L'ultimo è il collegamento principale e, come la mainfunzione di C , è l'unico collegamento eseguito per impostazione predefinita. I collegamenti rimanenti possono essere chiamati dal collegamento principale, ma non lo faremo qui.

Come in precedenza, þ(tabella) chiamerà ×(addizione) per ogni elemento nel suo argomento a sinistra e per ogni elemento nel suo argomento a destra, raggruppando i risultati per ciascun argomento a destra in una singola riga.

Poiché entrambi gli argomenti ×þsono numeri interi, þli converte in intervalli, trasformando gli argomenti n e m in [1, ..., n] e [1, ..., m] .

Compito 4

×þfunziona come prima. I seguenti collegamenti sono monadici, rendendoli in cima , vale a dire, vengono applicati in aggiunta a quelli precedenti.

Dopo l'esecuzione ×þ, Fappiattisce l'array 2D risultante e Ṣordina l'array 1D risultante.

05AB1E , 18 17 byte

Compito 1

Ÿ

Provalo online

Compito 2

Ÿ²FD>})

Provalo online

Compito 3

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

Provalo online

Compito 4

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

Provalo online

spiegazioni

Compito 1

Ÿ     # range[n ... m]

Compito 2

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

Compito 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

Compito 4

˜          # flatten the result from Task 3
 {         # sort

MATL , 18 17 byte

Compito 1

&:

Provalo online!

Compito 2

&:O2G:h!+

Provalo online!

Compito 3

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

Provalo online!

Compito 4

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

Provalo online!

Spiegazione

Compito 1

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

Compito 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

Compito 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

Compito 4

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

Mathematica, 84 77 byte

Modifica: grazie a Martin Ender per aver salvato 7 byte.

Compito 1:

{n,m}n~Range~m

Puro Functioncon argomenti ne mquali output n~Range~m, la forma infix di Range[n,m].

Compito 2:

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

n~Range~m~Table~(m+1)crea un array 2D con m+1righe, in cui ogni riga è l'output dell'attività precedente. Quindi //0~Range~m+#&è l'applicazione postfix della funzione 0~Range~m+#&che si aggiunge effettivamente 0alla prima riga, 1alla seconda riga e così via fino a mper ilm+1 fila -esimo.

Compito 3:

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

Questo applica solo la funzione costante 1##&~Array~{n,m}&all'output dell'attività precedente.

Compito 4:

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

Flattense Sortla tabella di moltiplicazione.

Python, 183 byte

Attività 1, 29 byte

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

Provalo online!

Attività 2, 84 byte

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

Provalo online!

Attività 3, 137 byte

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

Provalo online!

Attività 4, 183 167 byte

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

Provalo online!

Spiegazione:

Compito 1:

Abbastanza semplice, genera un na mlista usando di Python built-in rangefunzione.

Compito 2:

Per ogni numero 0a m+1, aggiunge quel numero a ciascun elemento di un elenco da na m.

Compito 3:

Per ogni numero da 1a m, moltiplica quel numero per ogni numero in un elenco da 1a n.

Compito 4:

Questo utilizza la sortedfunzione integrata di Python che ordina un elenco dal meno al più grande. La comprensione dell'elenco nella funzione viene utilizzata per appiattire l'elenco. Crea un elenco di ogni elemento in ogni elemento dell'elenco assegnatogli dall'attività 3.

• Salvati moltissimi byte grazie a @math_junkie.
• 16 byte salvati grazie a @ThisGuy

Salvati moltissimi byte grazie a @math_junkie.

PHP 7, 200 byte

Utilizza il buffer di output per cancellare l'output precedente.

Compito 1

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

Salva il codice $sper riutilizzarlo in seguito. Il$v variabile è per l'ultima attività.

Compito 2

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

Stampa le righe rimanenti.

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

Cancella il buffer di output e stampa la tabella di moltiplicazione, salvando i numeri in $v.

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

Cancella di nuovo il buffer di output e stampa $v.

PowerShell , 126 byte

Compito 1

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

Provalo online!

Utilizza l' ..operatore di portata integrato. Il comportamento predefinito per implicito Write-Outputinserisce una nuova riga tra gli elementi, quindi è per questo che l'output viene visualizzato come una nuova riga separata.

Compito 2

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

Provalo online!

Discariche il primo compito da STDERR con >2;, poi loop da 0a $m, ogni iterazione impostazione helper $iprima loop nuovamente da $na $me incrementando ogni numero da $i. Questi sono -joinassociati a virgole, altrimenti si tratterebbe di un'ambigua uscita gigantesca lunga per elemento per riga.

Compito 3

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

Provalo online!

Stesso genere di cose >2;per scaricare il precedente su STDERR. Poi abbiamo semplicemente doppio anello da 1per $mpoi1 a $n, impostando l'helper $ilungo la strada, moltiplicando i valori e -joincon uno spazio per renderlo tabulare. Nota le parentesi incapsulanti - entreranno in gioco al prossimo compito - ma qui assicurano solo che l'output sia messo sulla pipeline (cosa che sarebbe già, quindi sono ridondanti).

Compito 4

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

Provalo online!

Aha! Finalmente un po 'di ridondanza. Dal momento che l'attività precedente ha parentesi, possiamo puntare -splitsullo spazio bianco senza preoccupazioni, lanciare ognuno su un numero intero|%{+$_} e quindi |sort. L'output viene nuovamente separato da nuova riga.

Penso che ci siano alcuni modi per sfruttare meglio la ridondanza tra le attività, continuando a giocare a golf.

ES2016-ish, 401 384 caratteri

Ecco un primo tentativo. Sono sicuro che potrebbe essere un po 'condensato, ma è piuttosto corto. La freccia funziona FTW! (Adoro quelle dichiarazioni di ritorno implicite.) Nuovo e migliorato con stringhe modello!

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

Chiamata z(n,m) per l'output del registro. (Sto aliasing console.log per il golf successivo.)

Compito 2

Secondo verso ... si espande sul primo.

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`

Adesso chiama y(n,m) . Piuttosto no?

Compito 3

Devono bypassare la maggior parte delle funzionalità esistenti <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`

Ora il nome del metodo è v . Chiamalo allo stesso modo.

Compito 4

E ora possiamo riutilizzare di nuovo.

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

Ho dovuto saltare uper il mio metodo, quindi lo è t. Peccato che ho dovuto inserire quella funzione di ordinamento, perché i String.matchvalori restituiti come ... stringhe.

Rubino, 121 103 byte

Tutto in Ruby è vero tranne che per nile false, il che significa che i compiti possono essere impostati per ignorare l'input precedente con nullità ma ben posizionato and/ &&.

Compito 1

Provalo online!

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

Compito 2

Provalo online!

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

Compito 3

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

Compito 4

Provalo 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