मापांक योग

27

मैं इस अनुक्रम को "यीशु अनुक्रम" कहता हूं, क्योंकि यह आधुनिक का योग है । </ pun>

इस क्रम के लिए, आप सभी सकारात्मक पूर्णांक m को इनपुट n से कम लेते हैं, और प्रत्येक m के n modulo का योग लेते हैं । दूसरे शब्दों में:

an=∑m=1n−1nmodm

उदाहरण के लिए, 14 शब्द लें :

14 % 1 = 0
14 % 2 = 0
14 % 3 = 2
14 % 4 = 2
14 % 5 = 4
14 % 6 = 2
14 % 7 = 0
14 % 8 = 6
14 % 9 = 5
14 % 10 = 4
14 % 11 = 3
14 % 12 = 2
14 % 13 = 1
0+0+2+2+4+2+0+6+5+4+3+2+1=31

आपका लक्ष्य यहां एक फ़ंक्शन लिखना है जो इस अनुक्रम को लागू करता है। आपको अनुक्रम शब्द लेना चाहिए (यह 1 से 2 31 तक एक सकारात्मक पूर्णांक होगा ) केवल इनपुट के रूप में, और उस शब्द का मान आउटपुट करता है। यह OEIS A004125 है ।

हमेशा की तरह, मानक खामियां लागू होती हैं और बाइट्स में सबसे कम जवाब जीतता है!

code-golf  sequence  division 
— Nissa
स्रोत

जवाबों:

6

फंकी , 25 बाइट्स

n=>fors=~-i=1i<n)s+=n%i++

बस Naïve जवाब, काम करने लगता है।

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

डेसमोस , 25 बाइट्स।

f(x)=\sum_{n=1}^xmod(x,n)

डेसमोस में पेस्ट करें, फिर कॉल करके चलाएं f।

जब डेसमोस में चिपकाया जाता है, तो लेटेक्स इस तरह दिखता है

हालांकि ग्राफ जैसा दिखता है

यद्यपि यह यादृच्छिक और सभी जगह दिखता है, यह केवल पूर्णांक का समर्थन करने का परिणाम है।

RProgN 2 , 9 बाइट्स

x=x³x\%S+

व्याख्या की

x=x³x\%S+
x=          # Store the input in "x"
  x         # Push the input to the stack.
   ³x\%     # Define a function which gets n%x
       S    # Create a stack from "x" with the previous function. Thus this gets the range from (1,x), and runs (i%x) on each element.
        +   # Get the sum of this stack.

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

ReRegex , 71 बाइट्स

#import math
(_*)_a$/d<$1_>b$1a/(\d+)b/((?#input)%$1)+/\+a//u<#input
>a

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

ARBLE , 19 बाइट्स

sum(range(1,a)|a%i)

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

हो सकता है लैटरल , 56 बाइट्स

whenf is*{n=0whenx is*{ifx>0{n=n+f%x x--}elseprintn}x=f}

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

— Ataco
स्रोत
क्या इस चुनौती का सबमिशन कभी खत्म होगा? अब तक मुझे हर 40 मिनट में एक नया मिल रहा है: पी
— निसा
@StephenLeppik ओह, मैं अभी भी अधिक आ रहा हूं, चिंता न करें।
— अताको
@StephenLeppik नहीं बल्कि मैं चाहता हूँ, क्योंकि वे विभिन्न भाषाओं में विभिन्न गुणवत्ता के हैं।
— ATaco
@StephenLeppik मैंने उन्हें आपके लिए संयोजित किया है, begrudgingly।
— अताको
4
कृपया ऐसा न करें। अलग-अलग भाषाएं - यहां तक ​​कि अलग-अलग दृष्टिकोण - अलग-अलग उत्तरों में जाने चाहिए।
— डेनिस
4

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

lambda n:sum(map(lambda x:x%(n-x),range(n)))

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

संपादित करें: परिवर्तित रेंज (0, n) से रेंज (n)

— Max00355
स्रोत
2
नमस्कार, और साइट पर आपका स्वागत है! rangeसंक्षेप में 0, का पहला तर्क लेता है , इसलिए आप range(n)इसके बजाय दो बाइट्स द्वारा इसे छोटा कर सकते हैं ।
— DJMcMayhem
अरे वाह! मैंने ऐसा सोचा भी नहीं था। धन्यवाद
— Max00355
1
PPCG में आपका स्वागत है! आप map38 बाइट्स के बजाय सूची समझ का उपयोग कर सकते हैं : इसे ऑनलाइन आज़माएं!
— मिस्टर एक्सकोडर
आप सही हैं, लेकिन इसका इस्तेमाल नील के जवाब में किया गया था, इसलिए मुझे यकीन नहीं था कि अगर इसे कॉपी किया जाता तो यह सबसे अच्छी बात होती। जब तक मुझे यहां कुछ याद नहीं आ रहा है। मैं विकल्प पोस्ट करना चाहता था, भले ही यह थोड़ा लंबा था।
— मैक्स ००३५५
3

मानक एमएल (एमएलटन) , 53 51 बाइट्स

fn& =>let fun f 1a=a|f%a=f(% -1)(a+ &mod%)in f&0end

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

Ungolfed:

fn n =>
   let fun f 1 a = a
         | f x a = f (x-1) (a + n mod x)
   in  
       f n 0
   end

पिछला 53 बाइट संस्करण:

fn n=>foldl op+0(List.tabulate(n-1,fn i=>n mod(i+1)))

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

स्पष्टीकरण:

List.tabulateएक पूर्णांक xऔर एक फ़ंक्शन लेता है fऔर सूची बनाता है [f 0, f 1, ..., f(x-1)]। कुछ संख्या को देखते हुए n, हम शून्य से विभाजित होने से बचने के लिए और फ़ंक्शन के List.tabulateसाथ कॉल करते हैं । परिणामी सूची के साथ सारांशित है ।n-1fn i=>n mod(i+1)foldl op+0

— Laikoni
स्रोत
2

05AB1E , 6 बाइट्स

ÎGIN%+

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

मेरा पहला 05AB1E कार्यक्रम;)

Btw मुझे दो 39s मिले, JS6 के लिए 1 और अजगर के लिए 1, लेकिन मुझे बहुत देर हो चुकी थी

स्पष्टीकरण:

ÎGIN%+
Î                      # Push 0, then input, stack = [(accumulator = 0), I]
 G                     # For N in range(1, I), stack = [(accumulator)]
  IN                   # Push input, then N, stack = [(accumulator), I, N]
    %                  # Calculate I % N, stack = [(accumulator), I % N]
     +                 # Add the result of modulus to accumulator
— शायरु असकोतो
स्रोत
2

++ , 14 बाइट्स जोड़ें

L,RAdx$p@BcB%s

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

यह काम किस प्रकार करता है

L,   - Create a lambda function.
     - Example argument:     [7]
  R  - Range;        STACK = [[1 2 3 4 5 6 7]]
  A  - Argument;     STACK = [[1 2 3 4 5 6 7] 7]
  d  - Duplicate;    STACK = [[1 2 3 4 5 6 7] 7 7]
  x  - Repeat;       STACK = [[1 2 3 4 5 6 7] 7 [7 7 7 7 7 7 7]]
  $p - Swap and pop; STACK = [[1 2 3 4 5 6 7] [7 7 7 7 7 7 7]]
  @  - Reverse;      STACK = [[7 7 7 7 7 7 7] [1 2 3 4 5 6 7]]
  Bc - Zip;          STACK = [[7 1] [7 2] [7 3] [7 4] [7 5] [7 6] [7 7]]
  B% - Modulo each;  STACK = [0, 1, 1, 3, 2, 1, 0]
  s  - Sum;          STACK = [8]
— केर्ड सिक्काहिरिंग
स्रोत
2

विंडोज बैच (CMD), 63 बाइट्स

@set s=0
@for /l %%i in (1,1,%1)do @set/as+=%1%%%%i
@echo %s%

पिछला 64-बाइट संस्करण:

@set/ai=%2+1,s=%3+%1%%i
@if %i% neq %1 %0 %1 %i% %s%
@echo %s%
— नील
स्रोत
2

टी-एसक्यूएल, 80 79 बाइट्स

-1 बाइट @ मिकी को धन्यवाद

WITH c AS(SELECT @ i UNION ALL SELECT i-1FROM c WHERE i>1)SELECT SUM(@%i)FROM c

नामित पूर्णांक पैरामीटर से इनपुट प्राप्त होता है @, कुछ इस प्रकार है:

DECLARE @ int = 14;

एक सामान्य तालिका अभिव्यक्ति का उपयोग करता है जिससे की संख्या उत्पन्न होती 1है n। फिर उस cte का उपयोग moduluses को योग करने के लिए करता है।

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

इसे आज़माएं (SEDE)

कम "SQL-y" तरीका केवल 76 बाइट्स है। इस बार के @iबजाय इनपुट चर @(एक बाइट बचाता है) है। यह सिर्फ एक whileलूप करता है ।

DECLARE @ int=2,@o int=0WHILE @<@i BEGIN SELECT @o+=@i%@,@+=1 END PRINT @o
— ब्रायन जे
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.