Nesse desafio, você terá quatro tarefas diferentes, mas um tanto relacionadas, que devem ser resolvidas de uma maneira específica. Primeiro, explicarei as tarefas e, a seguir, uma explicação de como você deve resolvê-las.

Para todas as quatro tarefas, seu código deve receber dois números inteiros positivos como entrada:, n,monde n<m. Todas as tarefas devem ser resolvidas no mesmo idioma. A orientação das matrizes é opcional (n por m pode ser interpretado como "n linhas, m colunas" ou "n colunas, m linhas").

Tarefa 1:

Criar (e de saída / impressão) um vetor / list composto pelos elementos: n, n+1 ... m-1, m. Assim, para n=4, m=9, você deve saída: 4,5,6,7,8,9.

Tarefa 2:

Crie (e produza / imprima) uma matriz / matriz / lista de listas (ou equivalente) com esta aparência:

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

Para n=4, m=9você deve produzir:

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

Tarefa 3:

Crie (e produza / imprima) uma tabela de multiplicação n por m (em qualquer formato adequado). Exemplo para 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

Tarefa 4:

Saída / impressão de um vetor / lista que consiste nos elementos na tabela de multiplicação da tarefa 3, classificados em ordem crescente, mantendo valores duplicados. Para n=4, m=9, você deve saída: 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.

O desafio:

Agora, todas as tarefas acima são bastante triviais. O verdadeiro desafio aqui é que o código da tarefa 2 deve começar com o código da tarefa 1, o código da tarefa 3 deve começar com o código da tarefa 2 e o código da tarefa 4 deve começar com o código da tarefa 3.

Para deixar mais claro:

Suponha que o código da tarefa 1 seja (funciona na oitava):

@(n,m)(n:m)

Em seguida, seu código para a Tarefa 2 pode ser (funciona no Octave):

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

O código da tarefa Tarefa 3 deve ser (não funciona no Octave):

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

E, finalmente, o código da Tarefa 4 deve ser (não funciona no Octave):

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

Isso é código-golfe ; portanto, a submissão com o código mais curto da tarefa 4 em cada idioma vence. Como sempre: as explicações são altamente encorajadas.

Gelatina , 12 bytes

Tarefa 1

r

Experimente online!

Tarefa 2

r+þ0r$}

Experimente online!

Tarefa 3

r+þ0r$}
×þ

Experimente online!

Tarefa 4

r+þ0r$}
×þFṢ

Experimente online!

Como funciona

Tarefa 1

ré o átomo do intervalo diádico e faz exatamente o que a tarefa pede.

Tarefa 2

Uma cadeia diádica que começa com três elos diádicos é um garfo ; os links mais externos são avaliados primeiro e, em seguida, o link do meio é chamado com os resultados dos dois lados como argumentos.

• rcomporta-se como antes, produzindo [n,…, m] .

• 0r$} é um link rápido (ou link rápido, se você desejar).

  A rápida $(cadeia monádica) consome os elos 0(rendimento 0 ) e r(faixa diádica) e os transforma em uma cadeia monádica. Quando chamado com o argumento k , isso produzirá [0,…, k] .

  O quick }(argumento correto) pega o link rápido criado por $e o transforma em um link diádico que chama 0r$com 0r$}o argumento correto.

  0r$}será chamado com o argumento esquerdo n e o argumento direito m , portanto, 0r$é aliado ao argumento m e produz [0,…, m] .

• +þé outro link rápido. þ(tabela) chamará +(adição) para cada elemento em seu argumento esquerdo e qualquer elemento em seu argumento direito, agrupando os resultados para cada argumento direito em uma única linha.

  +þserá chamado com o argumento esquerdo [n,…, m] e o argumento direito [0,…, m] , produzindo a tabela desejada.

Tarefa 3

Cada linha em um programa Jelly define um link diferente. O último é o link principal e, como a mainfunção de C , é o único link executado por padrão. Os links restantes podem ser chamados no link principal, mas não faremos isso aqui.

Como antes, þ(tabela) chamará ×(adição) para cada elemento em seu argumento esquerdo e qualquer elemento em seu argumento direito, agrupando os resultados para cada argumento direito em uma única linha.

Como os dois argumentos ×þsão inteiros, os þconverte em intervalos, transformando os argumentos n e m em [1,…, n] e [1,…, m] .

Tarefa 4

×þfunciona como antes. Os links a seguir são monádicos, tornando-os no topo , ou seja, são aplicados sobre os anteriores.

Após a execução ×þ, Fnivela a matriz 2D resultante e Ṣclassifica a matriz 1D resultante.

05AB1E , 18 17 bytes

Tarefa 1

Ÿ

Experimente online

Tarefa 2

Ÿ²FD>})

Experimente online

Tarefa 3

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

Experimente online

Tarefa 4

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

Experimente online

Explicações

Tarefa 1

Ÿ     # range[n ... m]

Tarefa 2

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

Tarefa 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

Tarefa 4

˜          # flatten the result from Task 3
 {         # sort

MATL , 18 17 bytes

Tarefa 1

&:

Experimente online!

Tarefa 2

&:O2G:h!+

Experimente online!

Tarefa 3

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

Experimente online!

Tarefa 4

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

Experimente online!

Explicação

Tarefa 1

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

Tarefa 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

Tarefa 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

Tarefa 4

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

Mathematica, 84 77 bytes

Edit: Obrigado a Martin Ender por salvar 7 bytes.

Tarefa 1:

{n,m}n~Range~m

Puro Functioncom argumentos ne mquais saídas n~Range~m, a forma infix de Range[n,m].

Tarefa 2:

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

n~Range~m~Table~(m+1)cria uma matriz 2D com m+1linhas, onde cada linha é a saída da tarefa anterior. Em seguida, //0~Range~m+#&é a aplicação postfix da função 0~Range~m+#&que efetivamente adiciona 0à primeira linha, 1à segunda linha e assim por diante até mom+1 -a linha.

Tarefa 3:

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

Isso apenas aplica a função constante 1##&~Array~{n,m}&à saída da tarefa anterior.

Tarefa 4:

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

Flattense es Sorta tabuada de multiplicação.

Python, 183 bytes

Tarefa 1, 29 bytes

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

Experimente online!

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

Experimente online!

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

Experimente online!

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

Experimente online!

Explicação:

Tarefa 1:

Bastante simples, ele gera um na mlista usando Python built-in rangefunção.

Tarefa 2:

Para cada número 0até m+1, ele adiciona esse número a cada item de uma lista de naté m.

Tarefa 3:

Para cada número de 1até m, ele multiplica esse número por cada número em uma lista de 1até n.

Tarefa 4:

Isso usa a sortedfunção incorporada do Python, que classifica uma lista do menor para o maior. A compreensão da lista na função é usada para achatar a lista. Ele cria uma lista de todos os itens da lista fornecida pela tarefa 3.

• Salvei muitos bytes graças a @math_junkie.
• Guardado 16 bytes graças a @ThisGuy

Salvei muitos bytes graças a @math_junkie.

PHP 7, 200 bytes

Usa o buffer de saída para limpar a saída anterior.

Tarefa 1

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

Salva o código $spara reutilizá-lo mais tarde. o$v variável é para a última tarefa.

Tarefa 2

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

Imprime as linhas restantes.

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

Limpa o buffer de saída e imprime a tabela de multiplicação, salvando os números em $v.

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

Limpa o buffer de saída novamente e imprime $v.

PowerShell , 126 bytes

Tarefa 1

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

Experimente online!

Usa o ..operador de intervalo interno. O comportamento padrão para o implícito Write-Outputinsere uma nova linha entre elementos; é por isso que a saída é exibida como nova linha separada.

Tarefa 2

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

Experimente online!

Despeja a primeira tarefa para STDERR com e >2;, em seguida, executa um loop de 0para $mcada auxiliar de configuração de iteração $iantes de fazer um loop novamente de $npara $me incrementar cada número por $i. São -joineditadas com vírgulas; caso contrário, isso seria uma saída gigantesca e ambígua de um elemento por linha.

Tarefa 3

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

Experimente online!

O mesmo tipo de coisa >2;para despejar a anterior para STDERR. Simplesmente fazemos um loop duplo de 1para $mentão 1para $n, configurando o auxiliar $iao longo do caminho, multiplicando os valores e -joincom um espaço para torná-lo tabular. Observe os parênteses de encapsulamento - eles entrarão em jogo na próxima tarefa - mas aqui eles apenas garantem que a saída seja colocada no pipeline (o que já seria, então são redundantes).

Tarefa 4

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

Experimente online!

Aha! Finalmente alguma redundância. Como a tarefa anterior tem parênteses, podemos prender o -splitespaço em branco sem se preocupar, converter cada um em um número inteiro |%{+$_}e depois |sort. A saída é novamente separada por nova linha.

Eu acho que existem algumas maneiras de alavancar melhor a redundância entre as tarefas - ainda jogando golfe.

ES2016-ish, 401 384 caracteres

Aqui está uma primeira tentativa. Tenho certeza de que poderia ser um pouco condensado, mas é bem curto. A seta funciona FTW! (Adore essas instruções implícitas de retorno.) Novo e aprimorado com seqüências de caracteres de modelo!

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

Ligar z(n,m) para a saída do log. (Estou usando o nome console.log para jogar depois.)

Tarefa 2

Segundo verso ... expande no primeiro.

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`

Agora ligue y(n,m) . Bonita não?

Tarefa 3

Tem que ignorar a maioria das funcionalidades existentes <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`

Agora, o nome do método é v. Chame da mesma maneira.

Tarefa 4

E agora podemos reutilizar novamente.

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

Tive que pular upara o meu método, por isso é t. Desapontado, eu tive que colocar nessa função de classificação, porque os String.matchvalores retornados como ... strings.

Ruby, 121 103 bytes

Tudo em Ruby é truthy exceto nile false, o que significa que as tarefas pode ser configurado para ignorar a entrada anterior com nada além de um bem-colocado and/ &&.

Tarefa 1

Experimente online!

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

Tarefa 2

Experimente online!

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

Tarefa 3

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

Tarefa 4

Experimente 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