Trong Base-10, tất cả các ô vuông hoàn hảo kết thúc bằng 0 , 1 , 4 , 5 , 6 hoặc 9 .

Trong Base-16, tất cả các ô vuông hoàn hảo kết thúc bằng 0 , 1 , 4 hoặc 9 .

Nilknarf mô tả lý do tại sao và đây là cách giải quyết vấn đề này rất tốt trong câu trả lời này , nhưng tôi cũng sẽ đưa ra một mô tả ngắn gọn ở đây:

Khi bình phương một số Base-10, N , chữ số "cái" không bị ảnh hưởng bởi những gì trong chữ số "hàng chục" hoặc chữ số "hàng trăm", v.v. Chỉ có chữ số "cái" trong N ảnh hưởng đến chữ số "cái" trong N ² , vì vậy một cách dễ dàng (nhưng có thể không phải là gôn nhất) để tìm tất cả các chữ số cuối có thể có cho N ² là tìm n ² mod 10 cho tất cả 0 <= n < 10 . Mỗi kết quả là một chữ số cuối cùng có thể. Đối với Base-m, bạn có thể tìm thấy n ² mod m cho tất cả 0 <= n < m .

Viết chương trình, khi được cung cấp N đầu vào , sẽ xuất tất cả các chữ số cuối cùng có thể cho một hình vuông hoàn hảo trong Base-N (không trùng lặp). Bạn có thể giả sử N lớn hơn 0 và N đủ nhỏ để N ² không bị tràn (Nếu bạn có thể kiểm tra tất cả các cách lên đến N ² , tôi sẽ cung cấp cho bạn một số điểm hữu hạn, nhưng hãy biết rằng tỷ giá hối đoái của điểm brownie với điểm thực là vô cùng với một).

Các xét nghiệm:

 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

Đây là mã golf , vì vậy các quy tắc tiêu chuẩn được áp dụng!

(Nếu bạn thấy điều này quá dễ, hoặc bạn muốn có một câu hỏi sâu hơn về chủ đề này, hãy xem xét câu hỏi này: Độ che phủ tối thiểu của các cơ sở để kiểm tra dư lượng bậc hai về độ vuông góc ).

Thạch , 5 byte

R²%³Q

Hãy thử trực tuyến!

Giải trình

R²%³Q   Main link, argument: n

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

Google Sheets, 52 51 47 byte

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

_{^{Đã lưu 4 byte nhờ Taylor Scott}}

Trang tính sẽ tự động thêm 4 dấu ngoặc đơn đóng vào cuối công thức.

Nó không trả về kết quả theo thứ tự tăng dần nhưng nó trả về kết quả đúng.

05AB1E , 5 byte

Lns%ê

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

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

Swift , 47 35 32 * byte

* -3 cảm ơn @Alexander.

Có thể lần đầu tiên trong lịch sử quan hệ Swift đánh bại Python?

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

Hãy thử trực tuyến!

Giải trình

• (0..<m).map{}- Lặp lại qua phạm vi [0...m)và ánh xạ các kết quả sau:

• $0*$0%m- Bình phương của mỗi số nguyên modulo cơ sở m.

• Set(...) - Loại bỏ các bản sao.

• m in - Gán cơ sở cho một biến m

C #, 63 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 52 byte

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

Các trường hợp thử nghiệm

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

Phiên bản không đệ quy, 60 58 byte

Đã lưu 2 byte nhờ @ThePirateBay

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

Các trường hợp thử nghiệm

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

Bình thường, 6 byte

{%RQ*R

Dùng thử trực tuyến

Làm thế nào nó hoạt động

{%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

Brachylog , 10 9 byte

>ℕ^₂;?%≜ᶠ

Hãy thử trực tuyến!

Giải trình

       ≜ᶠ       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]

Japt , 7 6 byte

Dz%UÃâ

Kiểm tra nó

Lưu 1 byte nhờ Oliver

Giải trình

Đầu vào ngầm định của số nguyên U.

Ç   Ã

Tạo một mảng các số nguyên từ 0đến U-1, bao gồm và chuyển từng mặc dù một hàm.

²

Quảng trường.

%U

Modulo U.

â

Nhận tất cả các yếu tố duy nhất trong mảng và ngầm định kết quả.

Python 3 , 40 39 37 byte

-1 byte nhờ ông Xcoder. -2 byte nhờ Business Cat.

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

Hãy thử trực tuyến!

Trên thực tế , 11 byte

;╗r⌠²╜@%⌡M╔

Hãy thử trực tuyến!

Giải trình:

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

CJam , 12 byte

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

Khối ẩn danh chấp nhận một số và trả về một danh sách.

Hãy thử trực tuyến!

Giải trình

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

Haskell , 45 byte

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

-4 byte từ Anders Kaseorg

Hãy thử trực tuyến!

MATL , 6 5 byte

-1 byte nhờ @LuisMendo

:UG\u

Hãy thử trực tuyến!

Octave , 27 byte

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

Hãy thử trực tuyến!

Toán học, 30 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 48 byte

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>

43 byte nếu trả về một Setthay vì một mảng là chấp nhận được.

Scala , 32 30 byte

Sử dụng đơn giản các mẹo dễ dàng từ OP.

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

Hãy thử trực tuyến!

-2 byte nhờ @MrXcoder, với các ưu tiên (không cần ()* hoạt động xung quanh )

Tự hỏi: điều này có thể để ngầm nói với trình biên dịch để hiểu những thứ như (0 to n-1)map(x=>x*x%n)toSet(mà không phải import scala.language.postfixOps)?

Haskell , 44 byte

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

Hãy thử trực tuyến!

Võng mạc , 70 byte

.+
$*

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

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

Hãy thử trực tuyến! Cảnh báo: Chậm cho đầu vào lớn. Phiên bản 72 byte nhanh hơn một chút:

.+
$*

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

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

Hãy thử trực tuyến!

Clojure, 40 byte

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

Perl 6 , 19 byte

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

Kiểm tra nó

Mở rộng:

{ # 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
}

Bình thường , 13 byte

VQ aY.^N2Q){Y

Hãy thử trực tuyến.

Cố gắng giải thích:

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

Để sắp xếp đầu ra, chèn một Sbên vào bất kỳ phía nào của{

Tôi nghĩ nên có một cách ngắn hơn ...

Python 2 , 59 byte

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

Hãy thử trực tuyến!

PowerShell , 35 byte

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

Hãy thử trực tuyến!

R , 28 byte

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

Hãy thử trực tuyến!

Hồng ngọc ,31 30 byte

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

Hãy thử trực tuyến!

PHP , 53 byte

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

Lặp lại từ 0 đến số đầu vào, sử dụng n^2 mod basecông thức để đánh dấu các số đã được sử dụng. Nó đi đến vị trí đó trong một mảng, kiểm tra xem nó có được tăng lên không và xuất ra nếu nó không có. Sau đó, nó sẽ tăng nó sau đó để các giá trị trùng lặp không được in.

Hãy thử trực tuyến!

8 , 138 131 byte

Mã

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

Giải trình

[] - Tạo mảng đầu ra

swap dup >r - Lưu đầu vào để sử dụng sau

( 2 ^ r@ n:mod a:push ) 1 rot loop - Tính đầu vuông

rdrop - Làm sạch ngăn xếp r

' n:cmp a:sort - Sắp xếp mảng đầu ra

' n:cmp >r -1 a:@ swap ( tuck r@ w:exec ) a:filter rdrop nip - Loại bỏ các bản sao liên tiếp từ mảng

SED (Sơ đồ hiệu ứng ngăn xếp) là:a -- a

Cách sử dụng và ví dụ

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

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

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

Hãy thử trực tuyến!