20

Na Base-10, todos os quadrados perfeitos terminam em 0 , 1 , 4 , 5 , 6 ou 9 .

Na Base-16, todos os quadrados perfeitos terminam em 0 , 1 , 4 ou 9 .

Nilknarf descreve por que isso é e como resolver isso muito bem nesta resposta, mas também darei uma breve descrição aqui:

Ao quadrado um número da Base 10, N , o dígito "ones" não é afetado pelo que está no dígito "dezenas", ou no dígito "centenas", e assim por diante. Somente o dígito "uns" em N afeta o dígito "uns" em N ² , portanto, uma maneira fácil (mas talvez não a mais divertida) de encontrar todos os últimos dígitos possíveis para N ² é encontrar n ² mod 10 para todos os 0 <= n < 10 . Cada resultado é um último dígito possível. Para Base-m, você pode encontrar n ² mod m para todos os 0 <= n < m .

Escreva um programa que, quando recebida a entrada N , produz todos os últimos dígitos possíveis para um quadrado perfeito na Base-N (sem duplicatas). Você pode assumir que N é maior que 0 e que N é pequeno o suficiente para que N ² não transborde (se você puder testar até N ² , darei a você uma quantidade finita de pontos de brownie, mas saiba que a taxa de câmbio de pontos brownie para pontos reais é infinito para um).

Testes:

 Input -> Output
 1     -> 0
 2     -> 0,1
 10    -> 0,1,5,6,4,9
 16    -> 0,1,4,9
 31    -> 0,1,2,4,5,7,8,9,10,14,16,18,19,20,25,28
 120   -> 0,1,4,9,16,24,25,36,40,49,60,64,76,81,84,96,100,105

isso é código-golfe , então as regras padrão se aplicam!

(Se você acha isso muito fácil ou deseja uma pergunta mais aprofundada sobre o assunto, considere esta pergunta: Cobertura mínima de bases para teste de quadrática de resíduos de esquadria ).

code-golf number-theory abstract-algebra

— Lord Farquaad
fonte

1

A matriz de saída precisa ser classificada?

— Shaggy

@Shaggy Nope! Mego, duplicação não é permitida. Teoricamente, N poderia ser enorme, portanto duplicatas tornariam a saída bastante ilegível. Vou ADIT a questão

— Lord Farquaad

A saída de um conjunto é aceitável?

— totallyhuman

2

@totallyhuman Por que não seria válido? Conjuntos são coleções desordenadas e não deve ser ordenada , por isso ...

— O Sr. Xcoder

8

Gelatina , 5 bytes

R²%³Q

Experimente online!

Explicação

R²%³Q   Main link, argument: n

R       Range from 1 to n
 ²      Square each
  %³    Mod each by n
    Q   Deduplicate

— Gato de negócios
fonte

19

Planilhas Google, 52 51 47 bytes

=ArrayFormula(Join(",",Unique(Mod(Row(A:A)^2,A1

_{^{Guardado 4 bytes graças a Taylor Scott}}

As folhas adicionam automaticamente 4 parênteses de fechamento ao final da fórmula.

Ele não retorna os resultados em ordem crescente, mas retorna os resultados corretos.

— Engenheiro Toast
fonte

Vaca sagrada, homem que é assassino! Quem teria pensado? +1

— bearacuda13

1

Esta é definitivamente a minha resposta favorita até agora.

— Lord Farquaad

@LordFarquaad Estou surpreso e satisfeito por ter sido tão bem recebido. Eu tenho tentado jogar mais golfe no Planilhas e no Excel, embora - e em parte porque - eles tenham intervalos tão limitados. Isso levou a muitas fórmulas de matriz.

— Engenheiro Toast

Você deve ser capaz de largar a terminação )é de -4 bytes

— Taylor Scott

@TaylorScott Thanks! Vi esse truque em algum lugar recentemente - provavelmente em uma de suas respostas - e preciso lembrar de começar a usá-lo.

— Engenheiro brinde

6

05AB1E , 5 bytes

Lns%ê

Experimente online! ou como um conjunto de testes

L     # Range 1 .. input
 n    # Square each
  s%  # Mod by input
    ê # Uniquify (also sorts as a bonus)

— Riley
fonte

Como sfunciona aqui? A entrada é repetida?

— Luis Mendo

@LuisMendo sé pop a,b; push b,a. Quando um comando tenta tirar algo da pilha e não resta mais nada, a próxima entrada é usada. Se não houver mais nenhuma entrada, a última entrada será usada ( aqui está um exemplo ). Nesse caso, eu poderia ter usado o ¹que pressiona a primeira entrada, mas sfunciona melhor para o conjunto de testes.

— Riley

Obrigado. Você tem mais informações sobre o critério para o qual a entrada é reutilizada? (se houver, digamos, três entradas e você tentar exibir dois valores de uma pilha vazia)?

— Luis Mendo

1

A entrada @LuisMendo é usada em ordem até acabar, e continua a usar o último elemento. Você pode imaginar como se a pilha fosse preenchida com cada entrada em ordem e um número infinito do último elemento.

— Riley

@LuisMendo Ln¹%êé equivalente aqui. s.

— Magic Octopus Urn

6

Rápido , 47 35 32 * bytes

* -3 graças a @Alexander.

Possivelmente a primeira vez na história, os ~~laços~~ Swift superam o Python?

{m in Set((0..<m).map{$0*$0%m})}

Experimente online!

Explicação

(0..<m).map{}- Repete o intervalo [0...m)e mapeia os seguintes resultados:
$0*$0%m- O quadrado de cada número inteiro modulo a base m.
Set(...) - Remove as duplicatas.
m in - Atribui a base a uma variável m

— Mr. Xcoder
fonte

O nome de usuário está encerrado ... espere um segundo.

— Rohan Jhunjhunwala 28/07

1

É mais parecido com o Python. Isso é impressionante ! Eu pensei que nunca veria o dia que aconteceria.

— Caleb Kleveter 28/07

@CalebKleveter Thanks! Fico feliz que você achou impressionante :)

— Mr. Xcoder

3

C #, 63 bytes

using System.Linq;m=>new int[m].Select((_,n)=>n*n%m).Distinct()

Experimente online!

— TheLethalCoder
fonte

3

JavaScript (ES6), 52 bytes

f=(m,k=m,x={})=>k?f(x[k*k%m]=m,k-1,x):Object.keys(x)

Casos de teste

Mostrar snippet de código

f=(m,k=m,x={})=>k?f(x[k*k%m]=m,k-1,x):Object.keys(x)

;[1, 2, 10, 16, 31, 120]
.map(m => console.log(m + ' -> ' + f(m)))

Expandir snippet

Versão não recursiva, 60 58 bytes

Guardado 2 bytes graças a @ThePirateBay

m=>(a=[...Array(m).keys()]).filter(v=>a.some(n=>n*n%m==v))

Casos de teste

Mostrar snippet de código

let f =

m=>(a=[...Array(m).keys()]).filter(v=>a.some(n=>n*n%m==v))

;[1, 2, 10, 16, 31, 120]
.map(m => console.log(m + ' -> ' + f(m)))

Expandir snippet

— Arnauld
fonte

Não-recursivo 58 bytes:m=>(a=[...Array(m).keys()]).filter(v=>a.some(n=>n*n%m==v))

@ThePirateBay Good catch. Obrigado.

— Arnauld

3

Pitão, 6 bytes

{%RQ*R

Experimente online

Como funciona

{%RQ*RdQ    implicit variables
       Q    autoinitialized to eval(input())
    *R      over [0, …, Q-1], map d ↦ d times
      d         d
 %R         map d ↦ d modulo
   Q            Q
{           deduplicate

— Anders Kaseorg
fonte

3

Braquilog , 10 9 bytes

>ℕ^₂;?%≜ᶠ

Experimente online!

Explicação

       ≜ᶠ       Find all numbers satisfying those constraints:
    ;?%           It must be the result of X mod Input where X…
  ^₂              …is a square…
>ℕ                …of an integer in [0, …, Input - 1]

— Fatalizar
fonte

Eu estava prestes a sugerir {>≜^₂;?%}ᵘcomo uma alternativa ... então percebi que também há números negativos. > _ <

— Erik the Outgolfer

1

@EriktheOutgolfer Depois que uma confirmação é solicitada ao TIO, eu posso realmente reduzir essa resposta para 9 bytes usando ≜.

— Fatalize 27/07

OK ... como isso funcionaria quando há números negativos também? Simplesmente os ignoraria ou algo assim?

— Erik the Outgolfer

O mod @EriktheOutgolfer pode ser definido como o restante da divisão, o que seria positivo (o quociente recebe o sinal). EDIT: também, os quadrados são positivos.

— jaxad0127

@ jaxad0127 Acho que não é o caso aqui, pois >ainda seria responsável por números negativos.

— Erik the Outgolfer

3

Japonês , 7 6 bytes

Ç²%UÃâ

Teste-o

1 byte salvo graças a Oliver

Explicação

Entrada implícita de número inteiro U.

Ç   Ã

Crie uma matriz de números inteiros de 0para U-1, inclusive e passe cada uma por uma função.

²

Quadrado.

%U

Módulo U.

â

Obtenha todos os elementos exclusivos da matriz e produza implicitamente o resultado.

— Shaggy
fonte

1

Não acho que o alcance precise ser inclusivo. Ç²%UÃâParece funcionar bem.

— 267 Oliver Oliver

2

Python 3 , 40 39 37 bytes

-1 byte graças ao Sr. Xcoder. -2 bytes graças ao Business Cat.

lambda m:[*{n*n%m for n in range(m)}]

Experimente online!

— totalmente humano
fonte

1

Você não pode substituir n**2com n*n?

— Mr. Xcoder

Sim, sempre esqueça isso. > <Obrigado!

— totallyhuman

2

Além disso, range(m)é suficiente

— Business Cat

1

Você pode usar conjuntos para 34 bytes

— Mr. Xcoder

2

Na verdade , 11 bytes

;╗r⌠²╜@%⌡M╔

Experimente online!

Explicação:

;╗r⌠²╜@%⌡M╔
;╗           store a copy of m in register 0
  r          range(m)
   ⌠²╜@%⌡M   for n in range:
    ²          n**2
     ╜@%       mod m
          ╔  remove duplicates

— Mego
fonte

2

CJam , 12 bytes

{_,_.*\f%_&}

Bloco anônimo que aceita um número e retorna uma lista.

Experimente online!

Explicação

_,          Copy n and get the range [0 .. n-1]
  _.*       Multiply each element by itself (square each)
     \f%    Mod each by n
        _&  Deduplicate

— Gato de negócios
fonte

Agradável! Eu tinha {:X{_*X%}%_&}13 bytes

— Luis Mendo

2

Haskell , 45 bytes

import Data.List
f m=nub[n^2`mod`m|n<-[0..m]]

-4 bytes de Anders Kaseorg

Experimente online!

— Mego
fonte

Infelizmente, a versão sem pontos f m=nub$map((`mod`m).(^2))[0..m]é tão longa, a menos que haja uma sintaxe sorrateira para se livrar de parênteses extras.

— Shooqie

2

MATL , 6 5 bytes

-1 byte graças a @LuisMendo

:UG\u

Experimente online!

— Cinaski
fonte

Obrigado! Examinei o documento procurando essa função, mas não consegui encontrá-la.

— Cinaski

BTW este intérprete criado por Suever tem pesquisa de documentação, você pode encontrá-lo útil

— Luis Mendo

1

Oitava , 27 bytes

@(n)unique(mod((1:n).^2,n))

Experimente online!

— Luis Mendo
fonte

1

Mathematica, 30 bytes

Union@Table[Mod[i^2,#],{i,#}]&

Experimente online!

— J42161217
fonte

1

JavaScript (ES6), 48 bytes

f=
n=>[...new Set([...Array(n)].map((_,i)=>i*i%n))]

<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>

Expandir snippet

43 bytes se retornar um Setarray em vez de uma matriz for aceitável.

— Neil
fonte

1

Scala , 32 30 bytes

Uso simples da dica fácil do OP.

(0 to n-1).map(x=>x*x%n).toSet

Experimente online!

-2 bytes graças a @MrXcoder, com prioridades (sem necessidade de ()volta* operação)

Pensando: é possível dizer implicitamente ao compilador para entender coisas como (0 to n-1)map(x=>x*x%n)toSet(sem a necessidade import scala.language.postfixOps)?

— V. Courtois
fonte

1

(0 to n-1).map(x=>x*x%n).toSetpor 30 bytes. A exponenciação tem maior precedência que o módulo.

— Mr. Xcoder

@ Mr.Xcoder ooh ~ obrigado :) #

— Courtois

1

Haskell , 44 bytes

f m=[k|k<-[0..m],or[mod(n^2)m==k|n<-[0..m]]]

Experimente online!

— Anders Kaseorg
fonte

0

Retina , 70 bytes

.+
$*

;$`¶$`
1(?=.*;(.*))|;1*
$1
(1+)(?=((.*¶)+\1)?$)

D`1*¶
^|1+
$.&

Experimente online! Aviso: Lento para entradas grandes. Versão um pouco mais rápida de 72 bytes:

.+
$*

$'¶$';
1(?=.*;(.*))|;1*
$1
+s`^((1+)¶.*)\2
$1
^1+

D`1*¶
^|1+
$.&

Experimente online!

— Neil
fonte

0

Clojure, 40 bytes

#(set(map(fn[x](mod(* x x)%))(range %)))

— MattPutnam
fonte

0

Perl 6 , 19 bytes

{set (^$_)»²X%$_}

Teste-o

Expandido:

{ # bare block lambda with implicit param ｢$_｣

  set        # turn the following into a Set (shorter than ｢unique｣)

      (
        ^$_  # a Range upto (and excluding) ｢$_｣
      )»²    # square each of them (possibly in parallel)

    X%       # cross modulus the squared values by

      $_     # the input
}

— Brad Gilbert b2gills
fonte

0

Pitão , 13 bytes

VQ aY.^N2Q){Y

Experimente online.

Esfarrapada tentativa de explicar:

VQ               for N in [0 .. input-1]
                   blank space to supress implicit print inside the loop
     .^N2Q         N ^ 2 % input
   aY              append that to Y, which is initially an empty list
          )      end for
           {Y    deduplicate and implicit print

Para classificar a saída, insira um Sem qualquer lado do{

Eu acho que deveria haver uma maneira mais curta ...

— becos
fonte

1

Sim, o estilo funcional de Pyth tende a ser muito mais conciso . mapé seu amigo!

— Anders Kaseorg

0

Python 2 , 59 bytes

t=int(input())
print list(set([(i*i)%t for i in range(t)]))

Experimente online!

— Husnain Raza
fonte

0

PowerShell , 35 bytes

0..($n="$args")|%{$_*$_%$n}|sort -u

Experimente online!

— Joey
fonte

0

R , 28 bytes

unique((1:(n<-scan()))^2%%n)

Experimente online!

— Freira Furada
fonte

0

Rubi ,31 30 bytes

->m{(0..m).map{|n|n*n%m}.uniq}

Experimente online!

— Alexis Andersen
fonte

0

PHP , 53 bytes

for(;$i<$t=$argv[1];)$a[$z=$i++**2%$t]++?:print"$z
";

Faça um loop de 0 ao número de entrada, usando a n^2 mod basefórmula para marcar os números que foram usados. Ele vai para essa posição em uma matriz, verificando se foi incrementado e emitindo-o se não tiver. Em seguida, o incrementa para que os valores duplicados não sejam impressos.

Experimente online!

— Xanderhall
fonte

0

8o , 138 131 bytes

Código

[] swap dup >r ( 2 ^ r@ n:mod a:push ) 1 rot loop rdrop ' n:cmp a:sort ' n:cmp >r -1 a:@ swap ( tuck r@ w:exec ) a:filter rdrop nip

Explicação

[] - Criar matriz de saída

swap dup >r - Salvar entrada para uso posterior

( 2 ^ r@ n:mod a:push ) 1 rot loop - Calcular final quadrado

rdrop - Pilha r limpa

' n:cmp a:sort - Ordenar matriz de saída

' n:cmp >r -1 a:@ swap ( tuck r@ w:exec ) a:filter rdrop nip - Livre-se de duplicatas consecutivas da matriz

O SED (diagrama de efeito de pilha) é:a -- a

Uso e exemplo

: f [] swap dup >r ( 2 n:^ r@ n:mod a:push ) 1 rot loop rdrop ' n:cmp a:sort ' n:cmp >r -1 a:@ swap ( tuck r@ w:exec ) a:filter rdrop nip ;

ok> 120 f .
[0,1,4,9,16,24,25,36,40,49,60,64,76,81,84,96,100,105]

— Chaos Manor
fonte

0

Perl 5 , 41 + 1 (-n) = 42 bytes

$k{$n++**2%$_}++while$n<$_;say for keys%k

Experimente online!

— Xcali
fonte

Como termina o quadrado?

Gelatina , 5 bytes

Explicação

Planilhas Google, 52 51 47 bytes

05AB1E , 5 bytes

Rápido , 47 35 32 * bytes

Explicação

C #, 63 bytes

JavaScript (ES6), 52 bytes

Casos de teste

Versão não recursiva, 60 58 bytes

Casos de teste

Pitão, 6 bytes

Como funciona

Braquilog , 10 9 bytes

Explicação

Japonês , 7 6 bytes

Explicação

Python 3 , 40 39 37 bytes

Na verdade , 11 bytes

CJam , 12 bytes

Explicação

Haskell , 45 bytes

MATL , 6 5 bytes

Oitava , 27 bytes

Mathematica, 30 bytes

JavaScript (ES6), 48 bytes

Scala , 32 30 bytes

Haskell , 44 bytes

Retina , 70 bytes

Clojure, 40 bytes

Perl 6 , 19 bytes

Expandido:

Pitão , 13 bytes

Python 2 , 59 bytes

PowerShell , 35 bytes

R , 28 bytes

Rubi ,31 30 bytes

PHP , 53 bytes

8o , 138 131 bytes

Perl 5 , 41 + 1 (-n) = 42 bytes