Base-10에서 모든 완전 제곱은 0 , 1 , 4 , 5 , 6 또는 9로 끝납니다 .

Base-16에서 모든 완벽한 제곱은 0 , 1 , 4 또는 9로 끝납니다 .

Nilknarf는 이것이 왜 그리고이 답변 에서 이것을 잘 해결하는 방법을 설명하지만 여기에 간단한 설명도 제공합니다.

Base-10 숫자 N을 제곱 할 때 "1"자릿수는 "십"자릿수 또는 "100"자릿수 등의 영향을받지 않습니다. 만에 "사람"숫자 N은 의 "사람"자리에 영향을 N ⁽²⁾ 쉬운 (그러나 아마 golfiest를) 방법은 모든 가능한 마지막 자리를 찾을 수 있도록하기위한, N ^2를 찾는 것입니다 n은 ² 모드 (10)는 모두 0 <= N < 10 . 각 결과는 가능한 마지막 숫자입니다. Base-m의 경우 모든 0 <= n < m에 대해 n ² mod m 을 찾을 수 있습니다.

입력 N이 주어지면 Base-N의 완벽한 제곱을 위해 가능한 모든 마지막 숫자를 출력 하는 프로그램을 작성하십시오 (중복없이). 당신은 가정 할 수 N이 보다 큰 공 , 그리고 N는 것을 작은 충분 N ² 오버 플로우 (당신이 모든 방법을 테스트 할 수 있습니다하지 않을 경우 N ^(2)는 , 내가 당신에게 브라우니 점의 유한 한 양을 줄 것이다하지만 알고 브라우니 포인트와 실제 포인트의 환율은 1에 무한대입니다.

테스트 :

 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

이것은 code-golf 이므로 표준 규칙이 적용됩니다!

(: 당신은 너무 쉽게이를 발견 한 경우, 또는 당신은이 질문에 고려 주제에 대한보다 깊이있는 질문을 할 직각의 차 잔류 물 시험을위한 기지의 최소 덮개 ).

젤리 , 5 바이트

R²%³Q

온라인으로 사용해보십시오!

설명

R²%³Q   Main link, argument: n

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

Google 스프레드 시트, 52 51 47 바이트

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

_{^{Taylor Scott 덕분에 4 바이트 절약}}

시트는 수식 끝에 자동으로 4 개의 닫는 괄호를 추가합니다.

결과를 오름차순으로 반환하지는 않지만 올바른 결과를 반환합니다.

05AB1E , 5 바이트

Lns%ê

온라인으로 사용해보십시오! 또는 테스트 스위트

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

스위프트 , 47 35 32 * 바이트

* @Alexander 덕분에 -3.

아마도 역사상 처음으로 Swift의 관계 가 Python을 능가합니까?

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

온라인으로 사용해보십시오!

설명

• (0..<m).map{}-범위를 반복 [0...m)하고 다음 결과를 매핑합니다.

• $0*$0%m-각 정수 모듈러스의 제곱은 밑변 m입니다.

• Set(...) -중복을 제거합니다.

• m in -밑을 변수에 할당 m

C #, 63 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 52 바이트

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

테스트 사례

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

비 재귀 버전, 60 58 바이트

@ThePirateBay 덕분에 2 바이트 절약

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

테스트 사례

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

Pyth, 6 바이트

{%RQ*R

온라인으로 사용해보십시오

작동 원리

{%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 바이트

>ℕ^₂;?%≜ᶠ

온라인으로 사용해보십시오!

설명

       ≜ᶠ       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 바이트

Dz%UÃâ

그것을 테스트

Oliver 덕분에 1 바이트 절약

설명

정수의 묵시적 입력 U.

Ç   Ã

에서 0까지 의 정수 배열을 U-1만들고 각각 함수를 통해 전달합니다.

²

광장.

%U

모듈 U.

â

배열의 모든 고유 요소를 가져오고 결과를 내재적으로 출력합니다.

파이썬 3 , 40 39 37 바이트

Mr. Xcoder 덕분에 -1 바이트. Business Cat 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

Actually, 11 bytes

;╗r⌠²╜@%⌡M╔

Try it online!

Explanation:

;╗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 bytes

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

Anonymous block accepting a number and returning a list.

Try it online!

Explanation

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

Haskell, 45 bytes

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

-4 bytes from Anders Kaseorg

Try it online!

MATL, 6 5 bytes

-1 byte thanks to @LuisMendo

:UG\u

Try it online!

Octave, 27 bytes

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

Try it online!

Mathematica, 30 bytes

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

Try it online!

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>

43 bytes if returning a Set instead of an array is acceptable.

Scala, 32 30 bytes

Simple use of the easy tip from OP.

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

Try it online!

-2 bytes thanks to @MrXcoder, with priorities (no need for () around * operation)

Wondering: is this possible to implicitly tell the compiler to understand things like (0 to n-1)map(x=>x*x%n)toSet (without having to import scala.language.postfixOps)?

Haskell, 44 bytes

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

Try it online!

Retina, 70 bytes

.+
$*

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

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

Try it online! Warning: Slow for large inputs. Slightly faster 72-byte version:

.+
$*

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

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

Try it online!

Clojure, 40 bytes

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

Perl 6, 19 bytes

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

Test it

Expanded:

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

Pyth, 13 bytes

VQ aY.^N2Q){Y

Try online.

Lame attempt at explaining:

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

To sort the output, insert an S on any side of the {

I think there should be a shorter way...

Python 2, 59 bytes

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

Try it online!

PowerShell, 35 bytes

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

Try it online!

R, 28 bytes

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

Try it online!

Ruby, 31 30 bytes

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

Try it online!

PHP, 53 bytes

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

Loop from 0 to the input number, using the n^2 mod base formula to mark numbers that have been used. It goes to that position in an array, checking if it's been incremented and outputting it if it hasn't. It then increments it afterwards so duplicate values don't get printed.

Try it online!

8th, 138 131 bytes

Code

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

Explanation

[] - Create output array

swap dup >r - Save input for later use

( 2 ^ r@ n:mod a:push ) 1 rot loop - Compute square end

rdrop - Clean r-stack

' n:cmp a:sort - Sort output array

' n:cmp >r -1 a:@ swap ( tuck r@ w:exec ) a:filter rdrop nip - Get rid of consecutive duplicates from array

SED (Stack Effect Diagram) is: a -- a

Usage and example

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

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

Try it online!