Quadrados Perfeitos Sem Fronteiras

16

Dado n=m^2, retorne uma lista de números inteiros que não fazem fronteira com a m x mgrade de números inteiros 1 to n.

Exemplos

n = 1 (m = 1)

Rede:

[1]

Retorna:

[]

n = 4 (m = 2)

Rede:

[1,2]
[3,4]

Retorna:

[]

n = 9 (m = 3)

Rede:

[1,2,3]
[4,5,6]
[7,8,9]

Retorna:

[5]

n = 16 (m = 4)

Rede:

[ 1, 2, 3, 4]
[ 5, 6, 7, 8]
[ 9,10,11,12]
[13,14,15,16]

Retorna:

[6,7,10,11]

Para valores mais altos de m, esta resposta faz uma ótima visualização.

Regras:

  • Você pode participar mou n(onde n = m*m).
    • Se tomar no nque você está autorizado a ter um comportamento indefinido onde não há existe mpara n(EG 15).
    • n > 0, m > 0: Ambos devem ser valores inteiros.
  • A saída pode ser como uma matriz 1D / 2D, delimitada por matriz ou espaço em branco
  • A saída deve estar em ordem do menor para o maior.
    • Se produzir como uma matriz, isso significa que deve ser como seria na grade.
  • Isso é código-golfe , vitórias mais baixas na contagem de bytes.
code-golf  matrix 
— Urna de polvo mágico
fonte
Falha completa do meu lado, eu li incorretamente.
— DevelopingDeveloper
3
@DevelopingDeveloper Ei cara, se eu tivesse um níquel por cada vez que eu fosse capaz de comprar uma cerveja ou duas.
— Magic Octopus Urn
Se estiver produzindo como uma matriz 2D, uma única matriz vazia pode ser incluída no resultado?
— Shaggy

Respostas:

6

Oitava , 26 bytes

@(m)find((t=[0:m-2 0])'*t)

O código define uma função anônima que insere me gera um vetor de coluna (possivelmente vazio).

Experimente online!

Explicação

@(m)                          % Define anonymous function of m
          t=[0:m-2 0]         % Build row vector [0 1 2 ... m-2 0] and assign it
                              % to variable t
         (           )'       % Complex-conjugate transpose into a column vector
                       *t     % Matrix-multiply that column vector times the row
                              % vector t. This gives an m×m matrix with zeros in
                              % the border and nonzeros in the other entries.
    find(                )    % Linear indices of nonzero entries. The result is
                              % in increasing order
— Luis Mendo
fonte
5

Gelatina , 8 bytes

’Ṗ×+€ṖḊ€

Um link monádico obtendo me retornando uma lista de listas (as linhas internas).

Experimente online!

Quão?

’Ṗ×+€ṖḊ€ - Link m                    e.g. 5
’        - decrement                      4
 Ṗ       - pop (implicit range of input)  [1,2,3]
  ×      - multiply by m                  [5,10,15]
     Ṗ   - pop m                          [1,2,3,4]
   +€    - add €ach                       [[6,7,8,9],[11,12,13,14],[16,17,18,19]]
      Ḋ€ - dequeue €ach                   [[7,8,9],[12,13,14],[17,18,19]]
— Jonathan Allan
fonte
Não estava com vontade de fazer o python;)?
— Magic Octopus Urn
3

Próton , 28 bytes

k=>filter(u=>1<u%k,k..k*~-k)

Experimente online!

Toma m como entrada.

Quão?

Filtra os números inteiros em [k, k 2 -k) que, quando divididos por k , produzem um restante maior que 1 . Isso garante que as duas extremidades sejam cortadas, porque a primeira produz 0 e a última produz 1 . Também é garantido o retorno de um valor mais alto para qualquer número inteiro válido, porque eles são consecutivos.

— Mr. Xcoder
fonte
2

MATL , 8 bytes

:G\1>&*f

Entrada é m. Saída são os números em ordem crescente.

Experimente online!

Explicação

Considere a entrada 4como um exemplo. 

:     % Implicit input: m. Push range [1 2 ... m-1 m]
      % STACK: [1 2 3 4]
G\    % Modulo m, element-wise
      % STACK: [1 2 3 0]
1>    % Greater than 1, element-wise.
      % STACK: [0 1 1 0]
&*    % Matrix of pair-wise products
      % STACK: [0 0 0 0;
                0 1 1 0;
                0 1 1 0;
                0 0 0 0]
f     % Column vector of linear indices of nonzeros. Implicit display
      % STACK: [ 6;
                 7;
                10;
                11]
— Luis Mendo
fonte
2

Lote, 85 bytes

@for /l %%i in (3,1,%1)do @for /l %%j in (3,1,%1)do @cmd/cset/a(%%i-2)*%1+%%j-1&echo(

Eu não posso fazer um loop facilmente de 2para, m-1então faço loop de 3para me ajusto no cálculo.

— Neil
fonte
2

Japonês, 12 bytes

Passei tanto tempo jogando golfe na extração de elementos que fiquei sem tempo para jogar golfe na geração do array. Agora também estou percebendo que podemos tomar ncomo entrada, para que eu possa salvar algo lá. Para ser revisitado ...

òUnU²)òU m¤c

Tente

Explicação

                 :Implicit input of integer U=m     :e.g., 4
   U²            :U squared                         :16
 Un              :Minus U                           :12
ò                :Range [U,U**2-U]                  :[4,5,6,7,8,9,10,11,12]
      òU         :Partitions of length U            :[[4,5,6,7],[8,9,10,11],[12]]
         m       :Map
          ¤      :  Remove first 2 elements         :[[6,7],[10,11],[]]
           c     :Flatten                           :[6,7,10,11]
— Shaggy
fonte
2

J , 23 19 bytes

-4 bytes graças ao FrownyFrog!

1 1}:@}.-@%:}:\1+i.

Experimente online!

Minha olução original:

J , 23 bytes

[:|:@}:@}.^:2-@%:]\1+i.

Pega n como entrada, retorna uma matriz

Como funciona

1+i. - gera uma lista 1..n

-@%: - encontra a raiz quadrada de n e a nega (m)

]\ - cria uma tabela (matriz) mxm da lista

^:2 - faça o seguinte duas vezes:

|:@}:@}. - solte a primeira linha, solte a última linha e transponha

[: - tampe o garfo

Experimente online!

— Galen Ivanov
fonte
1}:@}.-@%:}.@}:\1+i.
— precisa saber é o seguinte
1
Não,1 1}:@}.-@%:}:\1+i.
— FrownyFrog
@FrownyFrog - Legal, obrigado! Eu não sabia sobre o argumento deixado à esquerda na lista}.
— Galen Ivanov
2

Casca , 9 bytes

‼ȯTthS↑CN

Experimente online!

Explicação

‼ȯTthS↑CN  Implicit input, say m=4.
       CN  Cut the natural numbers by m: [[1,2,3,4],[5,6,7,8],[9,10,11,12],..
     S↑    Take first m lists: [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
‼ȯ         Do this twice:
    h       Remove last row,
   t        remove first row,
  T         transpose.
           Result is [[6,7],[10,11]]; print it implicitly.
— Zgarb
fonte
2

Japonês , 14 bytes

²õ òU ÅkJ ®ÅkJ

Toma mcomo entrada

Explicação

 ²õ òU ÅkJ ®ÅkJ                                      
                // U = input                         | 3
U²              // U squared                         | 9
  õ             // Range [1...U²]                    | [1,2,3,4,5,6,7,8,9]
    òU          // Cut into slices of U              | [[1,2,3],[4,5,6],[7,8,9]]
       Å        // Remove the first item             | [[4,5,6],[7,8,9]]
        kJ      // Remove the last item              | [[4,5,6]]
           ®    // Map:                              |
            ÅkJ //   Remove the first and last items | 5

Experimente online!

A solução utilizada ntambém é de 14 bytes:

õ òU¬ ÅkJ ®ÅkJ

Experimente online!

— Oliver
fonte
2

TI-BASIC, 44 43 bytes (tokenizado)

DC 4D 3F CE 4D 6D 32 3F CF 3F DE 2A 08 09 3F D0 3F 4D 71 32 3F 23 4D 70 32 70 58 70 32 B1 58 83 72 11 2B 58 2B 30 2B 72 0D 71 31

Versão legível:

:Input M
:If M≤2
:Then
:Disp "{}
:Else
:M-2
:seq(M+2+X+2int(X/Ans),X,0,Ans²-1

Infelizmente, era necessário imprimir listas vazias manualmente, pois o TI-BASIC normalmente não permite isso. Se o número mfor maior que dois, o código poderá ser reduzido para apenas 29 bytes .

— fakedad
fonte
1

Pyt , 13 bytes

ĐĐ⁻⁻ř*⇹⁻⁻ř⁺ɐ+

Porto de Resposta da geléia do Jonathan Allan

Explicação:

                    Implicit input (takes m)
ĐĐ                  Triplicate the input (push it on the stack two more times)
  ⁻⁻                Decrement top of stack twice
    ř               Push [1,2,...,m-2]
     *              Multiplies by m
      ⇹             Swaps top two items on stack
       ⁻⁻           Decrement (m-2 is now on top)
         ř          Push [1,2,...,m-2]
          ⁺         Increment each element by 1
           ɐ+       Add [2,3,...,m-1] to each element of [m,2m,...,m(m-2)]
                    Implicit print

Experimente online!

— mudkip201
fonte
1

Python, 111 bytes

def f(s):
 r=[]
 for i in[i[1:-1]for i in[[(j*s)+i+1 for i in range(s)]for j in range(s)][1:-1]]:r+=i
 return r
— sonrad10
fonte
1

Java 8 , 241 183 170 162 160 132 122 bytes

j->{if(j<3)return new int[1];int e[]=new int[j*j-4*j+4],x=0,i=0;for(;++i<=j*j;)if(!(i<j|i>j*j-j|i%j<2))e[x++]=i;return e;}

Experimente online!

O Java torna muito difícil (muitos bytes) quando você precisa criar uma matriz de tamanho um tanto "desconhecido".

  • -8 bytes graças ao Magic Octopus Urn
  • -28 bytes graças ao Sr. Xcoder
  • -10 bytes graças a Kevin Cruijssen
— DevelopingDeveloper
fonte
1
Além disso, sim, Java é difícil para o código-golfe. Mas você é obviamente bom nisso. Cara, você precisa verificar essa linguagem chamada Groovybasicamente Java de taquigrafia.
— Magic Octopus Urn
2
132 bytes removendo uma condição extra da instrução if e vários truques.
— Sr. Xcoder 3/02
1
122 bytes continuando a versão de 132 bytes do Mr.Xcoder acima combinando int, alterando ||para |e removendo os colchetes do corpo if de linha única.
— Kevin Cruijssen
1
— tetocat 24/10/19
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.