वर्ग का अंत कैसे होता है?

Question

बेस -10 में, सभी पूर्ण वर्ग 0 , 1 , 4 , 5 , 6 , या 9 में समाप्त होते हैं ।

बेस -16 में, सभी पूर्ण वर्ग 0 , 1 , 4 या 9 में समाप्त होते हैं ।

Nilknarf वर्णन करता है कि यह क्यों है और इस उत्तर में बहुत अच्छी तरह से कैसे काम करना है , लेकिन मैं यहां एक संक्षिप्त विवरण भी दूंगा:

बेस -10 नंबर, N को स्क्वेर करते समय, "दस" अंक या "सैकड़ों" अंक में क्या "से" अंक प्रभावित नहीं होता है, और इसी तरह। केवल में "लोगों" अंकों एन में "लोगों" अंकों को प्रभावित करता है एन ² के लिए एक आसान (लेकिन शायद नहीं golfiest) जिस तरह से हर संभव पिछले अंक खोजने के लिए इतना एन ² मिल रहा है n ² आधुनिक 10 सभी के लिए 0 <= n < १० । प्रत्येक परिणाम एक अंतिम अंतिम अंक है। Base-m के लिए, आप सभी 0 <= n < m के लिए n ² mod m पा सकते हैं ।

एक प्रोग्राम लिखें, जो इनपुट एन को दिए जाने पर बेस-एन (डुप्लिकेट के बिना) में एक पूर्ण वर्ग के लिए सभी संभावित अंतिम अंकों को आउटपुट करता है। आप मान सकते हैं एन से अधिक है 0 , और कहा कि एन , इतने छोटे कि है एन ² नहीं अतिप्रवाह (आप नीचे से ऊपर तक के लिए परीक्षण कर सकते हैं, तो होगा एन ² , मैं तुम्हें, ब्राउनी अंक की एक निश्चित राशि दे देंगे, लेकिन पता है कि वास्तविक बिंदुओं के लिए ब्राउनी बिंदुओं की विनिमय दर अनंत है)।

टेस्ट:

 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

यह कोड-गोल्फ है , इसलिए मानक नियम लागू होते हैं!

(यदि आपको यह बहुत आसान लगता है, या आप इस विषय पर अधिक गहन प्रश्न चाहते हैं, तो इस प्रश्न पर विचार करें: चौकोरता के द्विघात अवशेषों के परीक्षण के लिए अड्डों का न्यूनतम आवरण )।

Comments

क्या आउटपुट सरणी को सॉर्ट करने की आवश्यकता है?

— शैगी

@ शगुन नोप! मेगो, डुप्लीकेशन की अनुमति नहीं है। सैद्धांतिक रूप से, एन भारी हो सकता है, इसलिए डुप्लिकेट आउटपुट को बहुत ही अपठनीय बना देगा। मैं इस प्रश्न का पालन करता हूँ

— लॉर्ड फ़रक्वाड

क्या आउटपुट सेट स्वीकार्य है?

— जुआन

@totallyhuman यह मान्य क्यों नहीं होगा? सेट

— अनियोजित

Answer 1

जेली , 5 बाइट्स

R²%³Q

इसे ऑनलाइन आज़माएं!

व्याख्या

R²%³Q   Main link, argument: n

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

Answer 2

Google शीट, 52 51 47 बाइट्स

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

_{^{टेलर स्कॉट की बदौलत 4 बाइट्स बचाए}}

सूत्र के अंत में शीट स्वचालित रूप से 4 समापन कोष्ठक जोड़ेगी।

यह आरोही क्रम में परिणाम वापस नहीं करता है लेकिन यह सही परिणाम लौटाता है।

Comments

पवित्र गाय, वह मनुष्य जो हत्यारा है! किसने सोचा होगा? +1

— बीरकुडा 13

यह निश्चित रूप से मेरा पसंदीदा उत्तर है।

— लॉर्ड फरक्वाड

@LordFarquaad मैं आश्चर्यचकित हूं और प्रसन्न हूं कि यह इतनी अच्छी तरह से प्राप्त हुआ था। मैं शीट्स और एक्सेल में अधिक गोल्फ खेलने की कोशिश कर रहा हूं, भले ही - और आंशिक रूप से क्योंकि - उनके पास ऐसी सीमित सीमाएं हैं। यह बहुत सारे सरणी सूत्रों के कारण है।

— इंजीनियर टोस्ट

आपको )-4 बाइट्स के लिए टर्मिनेटिंग एस ड्रॉप करने में सक्षम होना चाहिए

— टेलर स्कॉट

@TaylorScott धन्यवाद! मैंने हाल ही में उस चाल को देखा - शायद आपके एक जवाब पर - और इसका उपयोग शुरू करने के लिए याद रखने की आवश्यकता है।

— इंजीनियर टोस्ट

Answer 3

05AB1E , 5 बाइट्स

Lns%ê

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

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

Comments

sयहाँ कैसे काम करता है? क्या इनपुट दोहराया गया है?

— लुइस मेंडू

@LuisMendo sहै pop a,b; push b,a। जब एक कमांड स्टैक से कुछ पॉप करने की कोशिश करता है और कुछ भी नहीं बचा है तो अगले इनपुट का उपयोग किया जाता है। यदि कोई और इनपुट नहीं है, तो अंतिम इनपुट का उपयोग किया जाता है ( यहां एक उदाहरण है )। इस मामले में मैं इस्तेमाल कर सकता था ¹जो पहले इनपुट को धक्का देता है, लेकिन sटेस्ट सूट के लिए बेहतर काम करता है।

— रिले

धन्यवाद। क्या आपके पास मापदंड के संबंध में अधिक जानकारी है जिसके लिए इनपुट का पुन: उपयोग किया जाता है? (यदि तीन इनपुट कहा गया है और आप खाली स्टैक से दो मानों को पॉप करने की कोशिश करते हैं)?

— लुइस मेंडू

@LuisMendo इनपुट का उपयोग तब तक किया जाता है जब तक यह बाहर नहीं निकल जाता है, फिर यह अंतिम तत्व का उपयोग करना जारी रखता है। आप इसकी कल्पना कर सकते हैं कि स्टैक क्रम में प्रत्येक इनपुट और अंतिम तत्व की एक अनंत संख्या के साथ गद्देदार था।

— रिले

@LuisMendo Ln¹%êयहां बराबर है। s।

— मैजिक ऑक्टोपस Urn

Answer 4

स्विफ्ट , 47 35 32 * बाइट्स

* -3 धन्यवाद @Alexander।

संभवतः इतिहास में पहली बार स्विफ्ट संबंधों ने पायथन की पिटाई की?

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

इसे ऑनलाइन आज़माएं!

---

व्याख्या

• (0..<m).map{}- मैं सीमा के माध्यम से प्राप्त करता हूं [0...m)और निम्नलिखित परिणामों को मैप करता हूं :

• $0*$0%m- प्रत्येक पूर्णांक का वर्ग आधार को मापता है m।

• Set(...) - डुप्लिकेट को निकालता है।

• m in - एक चर के लिए आधार निरुपित m

Comments

उपयोगकर्ता नाम की जांच ... एक सेकंड प्रतीक्षा करें।

— रोहन झुनझुनवाला

अधिक यह पायथन की धड़कन है। यह प्रभावशाली है ! मुझे लगता था कि मैं वह दिन कभी नहीं देखूंगा जो होगा।

— कालेब क्लेवेटर

@CalebKleveter धन्यवाद! मुझे खुशी है कि आपने इसे प्रभावशाली पाया :)

— श्री एक्सकोडर

Answer 5

सी #, 63 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 6

जावास्क्रिप्ट (ईएस 6), 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 बाइट्स

सहेजे गए 2 बाइट्स @ThePirateBay के लिए धन्यवाद

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

Comments

गैर-पुनरावर्ती 58 बाइट्स:m=>(a=[...Array(m).keys()]).filter(v=>a.some(n=>n*n%m==v))

@ ThePirateBay अच्छी पकड़। धन्यवाद।

— अरनुलद

Answer 7

अजगर, 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

Answer 8

ब्रेकीलॉग , 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]

Comments

मैं {>≜^₂;?%}ᵘएक विकल्प के रूप में सुझाव देने वाला था ... तब मुझे महसूस हुआ कि नकारात्मक संख्याएँ भी हैं। > _ <

— आउटगोल्फर जूल

@EriktheOutgolfer एक बार जब TIO के लिए कमिटमेंट हो जाती है, तो मैं वास्तव में इस बाइट को 9 बाइट्स वास्तव में उपयोग करके कम कर सकता हूं ≜।

— जूल 27'17 को घातक

ठीक है ... यह कैसे काम करेगा जब नकारात्मक संख्याएं भी हों? क्या यह केवल उन्हें या कुछ और अनदेखा करेगा?

— आउटगॉल्फ जूल

@EriktheOutgolfer mod को विभाजन के शेष भाग के रूप में परिभाषित किया जा सकता है, जो सकारात्मक होगा (भागफल चिन्ह लेता है)। संपादित करें: भी, वर्ग सकारात्मक हैं।

— jaxad0127

@ jaxad0127 मुझे नहीं लगता कि यहां ऐसा मामला है, क्योंकि >अभी भी नकारात्मक संख्याओं के लिए खाता हूँ।

— निकोलग्राफ जूल

Answer 9

जाप , 7 6 बाइट्स

Dz%UÃâ

झसे आज़माओ

1 बाइट ने ओलिवर को धन्यवाद दिया

---

व्याख्या

पूर्णांक का निहित इनपुट U।

Ç   Ã

से पूर्णांकों की एक सरणी बनाने 0के लिए U-1समावेशी, और एक समारोह हालांकि प्रत्येक गुजरती हैं।

²

स्क्वायर।

%U

मोडुलो U।

â

सरणी में सभी अद्वितीय तत्व प्राप्त करें और परिणाम को स्पष्ट रूप से आउटपुट करें।

Comments

मुझे नहीं लगता कि रेंज को समावेशी बनाने की जरूरत है। Dz%UÃâबस ठीक काम करने लगता है।

— ओलिवर

Answer 10

पायथन 3 , 40 39 37 बाइट्स

-1 बाइट मिस्टर एक्सकोडर की बदौलत। -2 बाइट्स बिजनेस कैट के लिए धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

Comments

आप को बदल नहीं सकता n**2के साथ n*n?

— मिस्टर एक्सकोडर

हाँ, हमेशा यह भूल जाओ। > <धन्यवाद!

— जुआन

इसके अलावा, बस range(m)पर्याप्त है

— व्यवसाय बिल्ली

आप 34 बाइट्स के

— श्री एक्सकोडर

Answer 11

दरअसल , 11 बाइट्स

;╗r⌠²╜@%⌡M╔

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

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

Answer 12

CJam , 12 बाइट्स

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

बेनामी ब्लॉक एक संख्या को स्वीकार करता है और एक सूची वापस करता है।

इसे ऑनलाइन आज़माएं!

व्याख्या

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

Comments

अच्छा! मैं {:X{_*X%}%_&}13 बाइट्स के लिए था

— लुइस मेंडू

Answer 13

हास्केल , 45 बाइट्स

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

-4 एंडर्स केसरग से बाइट्स

इसे ऑनलाइन आज़माएं!

Comments

दुख की बात f m=nub$map((`mod`m).(^2))[0..m]यह है कि जब तक अतिरिक्त कोष्ठक से छुटकारा पाने के लिए एक डरपोक वाक्यविन्यास नहीं है, तब तक केवल बिंदु-मुक्त संस्करण है।

— शौकी

Answer 14

MATL , 6 5 बाइट्स

-1 बाइट्स @LuisMendo को धन्यवाद

:UG\u

इसे ऑनलाइन आज़माएं!

Comments

धन्यवाद! मैंने उस फ़ंक्शन को खोज रहे डॉक्टर के माध्यम से देखा, लेकिन उसे ढूंढने में सक्षम नहीं था।

— सिनेस्की जू

BTW इस व्याख्याकार द्वारा बनाया गया है Suever प्रलेखन खोज है, आप इसे उपयोगी मिल सकता है

— लुइस मेंडो

Answer 15

ऑक्टेव , 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 16

गणितज्ञ, 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 17

जावास्क्रिप्ट (ईएस 6), 48 बाइट्स

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 बाइट्स अगर Setएक सरणी के बजाय वापस आना स्वीकार्य है।

Answer 18

स्काला , 32 30 बाइट्स

ओपी से आसान टिप का सरल उपयोग ।

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

इसे ऑनलाइन आज़माएं!

-2 बाइट्स प्राथमिकताओं के साथ @MrXcoder करने के लिए धन्यवाद, (के लिए कोई जरूरत नहीं ()चारों ओर *आपरेशन)

ताज्जुब है: करने के लिए यह संभव है परोक्ष जैसी चीजों को समझने के लिए संकलक बता (0 to n-1)map(x=>x*x%n)toSet(बिना import scala.language.postfixOps)?

Comments

(0 to n-1).map(x=>x*x%n).toSet30 बाइट्स के लिए। प्रतिपादक मॉडुलो की तुलना में अधिक पूर्वता है।

— मिस्टर एक्सकोडर

@ Mr.Xcoder ooh ~ धन्यवाद :)

— वी।

Answer 19

हास्केल , 44 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 20

रेटिना , 70 बाइट्स

.+
$*

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

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

इसे ऑनलाइन आज़माएं! चेतावनी: बड़े इनपुट के लिए धीमा। थोड़ा तेज़ 72-बाइट संस्करण:

.+
$*

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

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

इसे ऑनलाइन आज़माएं!

Answer 21

क्लोजर, 40 बाइट्स

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

Answer 22

पर्ल 6 , 19 बाइट्स

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

झसे आज़माओ

विस्तारित:

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

Answer 23

पायथ , 13 बाइट्स

VQ aY.^N2Q){Y

ऑनलाइन कोशिश करें।

समझाने पर लंगड़ा हुआ प्रयास:

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किसी भी तरफ डालें{

मुझे लगता है कि एक छोटा रास्ता होना चाहिए ...

Comments

हाँ, पायथ की कार्यात्मक शैली बहुत अधिक संक्षिप्त हो जाती है । mapआपका दोस्त है!

— एंडर्स केसरग

Answer 24

पायथन 2 , 59 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 25

पॉवरशेल , 35 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 26

आर , 28 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 27

माणिक ,31 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 28

PHP , 53 बाइट्स

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

उपयोग की n^2 mod baseगई संख्या को चिह्नित करने के लिए सूत्र का उपयोग करके इनपुट नंबर से 0 से लूप करें। यह सरणी में उस स्थिति में जाता है, अगर यह नहीं बढ़ाया गया है और यह आउटपुट कर रहा है अगर यह नहीं है की जाँच। इसके बाद यह वृद्धि करता है ताकि डुप्लिकेट मान मुद्रित न हों।

इसे ऑनलाइन आज़माएं!

Answer 29

8 वें , 138 131 बाइट्स

कोड

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

व्याख्या

[] - आउटपुट ऐरे बनाएं

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 - सरणी से लगातार डुप्लिकेट से छुटकारा पाएं

SED (स्टैक इफ़ेक्ट डायग्राम) है:a -- a

उपयोग और उदाहरण

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

Answer 30

पर्ल 5 , 41 + 1 (एन) = 42 बाइट्स

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

इसे ऑनलाइन आज़माएं!