20

In Base-10, tutti i quadrati perfetti terminano con 0 , 1 , 4 , 5 , 6 o 9 .

Nella Base-16, tutti i quadrati perfetti terminano con 0 , 1 , 4 o 9 .

Nilknarf descrive perché questo è e come risolverlo molto bene in questa risposta, ma darò anche una breve descrizione qui:

Quando si quadrano un numero Base-10, N , la cifra "uni" non è influenzata da ciò che è nella cifra "decine" o dalla cifra "centinaia" e così via. Solo la cifra "one" in N influenza la cifra " one " in N ² , quindi un modo semplice (ma forse non più golfistico) per trovare tutte le ultime cifre possibili per N ² è trovare n ² mod 10 per tutti 0 <= n < 10 . Ogni risultato è un'ultima cifra possibile. Per Base-m, puoi trovare n ² mod m per tutti 0 <= n < m .

Scrivi un programma che, quando viene dato l'ingresso N , emette tutte le ultime cifre possibili per un quadrato perfetto in Base-N (senza duplicati). Puoi presumere che N sia maggiore di 0 e che N sia abbastanza piccolo da non far traboccare N ² (se riesci a testare fino a N ² , ti darò una quantità finita di punti brownie, ma sappi che il tasso di cambio dei punti brownie in punti reali è infinito a uno).

test:

 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

questo è code-golf , quindi si applicano le regole standard!

(Se lo trovi troppo facile o vuoi una domanda più approfondita sull'argomento, considera questa domanda: Copertura minima delle basi per il test quadratico dei residui della quadratura ).

code-golf number-theory abstract-algebra

— Lord Farquaad
fonte

1

L'array di output deve essere ordinato?

— Shaggy,

@Shaggy Nope! Mego, la duplicazione non è consentita. Teoricamente, N potrebbe essere enorme, quindi i duplicati renderebbero il risultato piuttosto illeggibile. Devo rispondere alla domanda

— Lord Farquaad,

L'output di un set è accettabile?

— totalmente umano il

2

@totallyhuman Perché non dovrebbe essere valido? I set sono raccolte non ordinate e non devono essere ordinati , quindi ...

— Mr. Xcoder,

8

Gelatina , 5 byte

R²%³Q

Provalo online!

Spiegazione

R²%³Q   Main link, argument: n

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

— Gatto di affari
fonte

19

Fogli Google, 52 51 47 byte

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

_{^{Risparmiato 4 byte grazie a Taylor Scott}}

Fogli aggiungerà automaticamente 4 parentesi di chiusura alla fine della formula.

Non restituisce i risultati in ordine crescente ma restituisce i risultati corretti.

— Ingegnere Toast
fonte

Santa mucca, uomo che è un assassino spaventato! Chi avrebbe mai pensato? +1

— bearacuda13,

1

Questa è sicuramente la mia risposta preferita finora.

— Lord Farquaad,

@LordFarquaad Sono sorpreso e contento che questo sia stato così ben accolto. Ho cercato di giocare a golf di più in Fogli ed Excel anche se - e in parte perché - hanno range così limitati. Ha portato a molte formule di array.

— Ingegnere Toast,

Dovresti essere in grado di eliminare le )s di terminazione per -4 byte

— Taylor Scott,

@TaylorScott Grazie! Ho visto quel trucco da qualche parte di recente - probabilmente su una delle tue risposte - e devo ricordare di iniziare a usarlo.

— Ingegnere Toast,

6

05AB1E , 5 byte

Lns%ê

Provalo online! o come una suite di test

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

— Riley
fonte

Come sfunziona qui? L'ingresso è ripetuto?

— Luis Mendo,

@LuisMendo sè pop a,b; push b,a. Quando un comando tenta di estrarre qualcosa dallo stack e non viene lasciato nulla, viene utilizzato l'input successivo. Se non ci sono altri input, viene utilizzato l'ultimo input ( ecco un esempio ). In questo caso avrei potuto usare ciò ¹che spinge il primo input, ma sfunziona meglio per la suite di test.

— Riley,

Grazie. Hai altre informazioni sul criterio per il quale l'input viene riutilizzato? (se sono stati pronunciati tre input e si tenta di estrarre due valori da uno stack vuoto)?

— Luis Mendo,

1

@LuisMendo L'input viene utilizzato nell'ordine in cui si esaurisce, quindi continua a utilizzare l'ultimo elemento. Puoi immaginarlo come se lo stack fosse riempito con ogni input in ordine e un numero infinito dell'ultimo elemento.

— Riley,

@LuisMendo Ln¹%êè equivalente qui. s.

— Magic Octopus Urn,

6

Rapido , 47 35 32 * byte

* -3 grazie a @Alexander.

Forse la prima volta nella storia i ~~legami di~~ Swift battono Python?

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

Provalo online!

Spiegazione

(0..<m).map{}- Scorre la gamma [0...m)e mappa i seguenti risultati:
$0*$0%m- Il quadrato di ogni numero intero modulo la base m.
Set(...) - Rimuove i duplicati.
m in - Assegna la base a una variabile m

— Mr. Xcoder
fonte

Nome utente verificato ... aspetta un secondo.

— Rohan Jhunjhunwala,

1

Più come se batte Python. È impressionante ! Pensavo che non avrei mai visto il giorno che sarebbe successo.

— Caleb Kleveter,

@CalebKleveter Grazie! Sono contento che l'abbia trovato impressionante :)

— Mr. Xcoder,

3

C #, 63 byte

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

Provalo online!

— TheLethalCoder
fonte

3

JavaScript (ES6), 52 byte

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

Casi test

Mostra snippet di codice

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

Expand snippet

Versione non ricorsiva, 60 58 byte

Salvato 2 byte grazie a @ThePirateBay

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

Casi test

Mostra snippet di codice

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

Expand snippet

— Arnauld
fonte

58 byte non ricorsivi:m=>(a=[...Array(m).keys()]).filter(v=>a.some(n=>n*n%m==v))

@ThePirateBay Buona cattura. Grazie.

— Arnauld,

3

Pyth, 6 byte

{%RQ*R

Provalo online

Come funziona

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

Brachylog , 10 9 byte

>ℕ^₂;?%≜ᶠ

Provalo online!

Spiegazione

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

— Fatalize
fonte

Stavo per suggerire {>≜^₂;?%}ᵘcome alternativa ... poi mi sono reso conto che ci sono anche numeri negativi. > _ <

— Erik the Outgolfer,

1

@EriktheOutgolfer Una volta che un commit viene portato a TIO, posso effettivamente ridurre questa risposta a 9 byte effettivamente usando ≜.

— Fatalizza il

OK ... come funzionerebbe quando ci sono anche numeri negativi? Li ignorerebbe semplicemente o qualcosa del genere?

— Erik the Outgolfer,

La mod @EriktheOutgolfer può essere definita come resto della divisione, il che sarebbe positivo (il quoziente prende il segno). EDIT: inoltre, i quadrati sono positivi.

— jaxad0127,

@Jaxad0127 Non penso che sia il caso qui, dato >che spiegherebbe comunque numeri negativi dopo.

— Erik the Outgolfer,

3

Japt , 7 6 byte

Ç²%UÃâ

Provalo

1 byte salvato grazie a Oliver

Spiegazione

Input implicito di numero intero U.

Ç   Ã

Crea un array di numeri interi da 0a U-1, incluso e passa ciascuno attraverso una funzione.

²

Piazza.

%U

Modulo U.

â

Ottieni tutti gli elementi univoci nella matrice e genera implicitamente il risultato.

— ispido
fonte

1

Non credo che l'intervallo debba essere inclusivo. Ç²%UÃâsembra funzionare bene.

— Oliver,

2

Python 3 , 40 39 37 byte

-1 byte grazie a Mr. Xcoder. -2 byte grazie a Business Cat.

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

Provalo online!

— totallyhuman
fonte

1

Non puoi sostituirlo n**2con n*n?

— Mr. Xcoder,

Sì, dimenticalo sempre. > <Grazie!

— totalmente umano il

2

Inoltre, range(m)è sufficiente

— Business Cat,

1

Puoi usare set per 34 byte

— Mr. Xcoder,

2

In realtà , 11 byte

;╗r⌠²╜@%⌡M╔

Provalo online!

Spiegazione:

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

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

Blocco anonimo che accetta un numero e restituisce un elenco.

Provalo online!

Spiegazione

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

— Gatto di affari
fonte

Bello! Ho avuto {:X{_*X%}%_&}per 13 byte

— Luis Mendo il

2

Haskell , 45 byte

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

-4 byte da Anders Kaseorg

Provalo online!

— Mego
fonte

La versione purtroppo senza punti f m=nub$map((`mod`m).(^2))[0..m]è altrettanto lunga, a meno che non ci sia una sintassi subdola per sbarazzarsi di parentesi extra.

— shooqie,

2

MATL , 6 5 byte

-1 byte grazie a @LuisMendo

:UG\u

Provalo online!

— Cinaski
fonte

Grazie! Ho cercato nel documento la ricerca di quella funzione ma non sono riuscito a trovarla.

— Cinaski,

A proposito questo interprete creato da Suever ha la ricerca della documentazione, potresti trovarlo utile

— Luis Mendo,

1

Ottava , 27 byte

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

Provalo online!

— Luis Mendo
fonte

1

Mathematica, 30 byte

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

Provalo online!

— J42161217
fonte

1

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>

Espandi frammento

43 byte se Setè accettabile la restituzione di un array anziché di un array.

— Neil
fonte

1

Scala , 32 30 byte

Semplice utilizzo della punta facile da OP.

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

Provalo online!

-2 byte grazie a @MrXcoder, con priorità (non è necessario il funzionamento in ()giro *)

Chiedendosi: è possibile dire implicitamente al compilatore di capire cose come (0 to n-1)map(x=>x*x%n)toSet(senza dovere import scala.language.postfixOps)?

— V. Courtois
fonte

1

(0 to n-1).map(x=>x*x%n).toSetper 30 byte. L'esponenziazione ha una precedenza maggiore rispetto al modulo.

— Mr. Xcoder,

@ Mr.Xcoder ooh ~ grazie :)

— V. Courtois,

1

Haskell , 44 byte

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

Provalo online!

— Anders Kaseorg
fonte

0

Retina , 70 byte

.+
$*

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

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

Provalo online! Avviso: lento per ingressi di grandi dimensioni. Versione a 72 byte leggermente più veloce:

.+
$*

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

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

Provalo online!

— Neil
fonte

0

Clojure, 40 byte

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

— MattPutnam
fonte

0

Perl 6 , 19 byte

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

Provalo

Allargato:

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

Pyth , 13 byte

VQ aY.^N2Q){Y

Prova online.

Tentativo tentativo di spiegare:

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

Per ordinare l'output, inserire un Sda qualsiasi lato del{

Penso che dovrebbe esserci un modo più breve ...

— Alleks
fonte

1

Sì, lo stile funzionale di Pyth tende ad essere molto più conciso . mapÈ tuo amico!

— Anders Kaseorg,

0

Python 2 , 59 byte

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

Provalo online!

— Husnain Raza
fonte

0

PowerShell , 35 byte

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

Provalo online!

— Joey
fonte

0

R , 28 byte

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

Provalo online!

— Perdente Suora
fonte

0

rubino ,31 30 byte

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

Provalo online!

— Alexis Andersen
fonte

0

PHP , 53 byte

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

Passa da 0 al numero di input, usando la n^2 mod baseformula per contrassegnare i numeri che sono stati utilizzati. Va in quella posizione in un array, controllando se è stato incrementato e emettendolo se non lo è. Successivamente lo incrementa in modo che i valori duplicati non vengano stampati.

Provalo online!

— Xanderhall
fonte

0

8 ° , 138 131 byte

Codice

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

Spiegazione

[] - Crea array di output

swap dup >r - Salva input per un uso successivo

( 2 ^ r@ n:mod a:push ) 1 rot loop - Calcola l'estremità quadrata

rdrop - Pulisci r-stack

' n:cmp a:sort - Ordina array di output

' n:cmp >r -1 a:@ swap ( tuck r@ w:exec ) a:filter rdrop nip - Elimina i duplicati consecutivi dall'array

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

Uso ed esempio

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

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

Provalo online!

— Xcali
fonte

Come finisce il quadrato?

Gelatina , 5 byte

Spiegazione

Fogli Google, 52 51 47 byte

05AB1E , 5 byte

Rapido , 47 35 32 * byte

Spiegazione

C #, 63 byte

JavaScript (ES6), 52 byte

Casi test

Versione non ricorsiva, 60 58 byte

Casi test

Pyth, 6 byte

Come funziona

Brachylog , 10 9 byte

Spiegazione

Japt , 7 6 byte

Spiegazione

Python 3 , 40 39 37 byte

In realtà , 11 byte

CJam , 12 byte

Spiegazione

Haskell , 45 byte

MATL , 6 5 byte

Ottava , 27 byte

Mathematica, 30 byte

JavaScript (ES6), 48 byte

Scala , 32 30 byte

Haskell , 44 byte

Retina , 70 byte

Clojure, 40 byte

Perl 6 , 19 byte

Allargato:

Pyth , 13 byte

Python 2 , 59 byte

PowerShell , 35 byte

R , 28 byte

rubino ,31 30 byte

PHP , 53 byte

8 ° , 138 131 byte

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