39

एक बल्कि उत्सुक संख्या है जो कभी-कभी गणित की समस्याओं या पहेलियों में दिखाई देती है। Pseudofactorial (N) N के माध्यम से संख्या 1 का सबसे कम (यानी निम्नतम) सामान्य गुण है; दूसरे शब्दों में, यह सबसे कम संख्या है जिसमें कारकों के रूप में एन के माध्यम से 1 से सभी संख्याएं हैं।

उदाहरण के लिए स्यूडोफैक्टीरियल (7) = 3 * 4 * 5 * 7, जो कि 7 जैसा ही है! सिवाय इसके कि 2 और 6 को हटा दिया गया है क्योंकि वे अन्य शर्तों में निहित हैं।

स्यूडोफैक्टीरियल (एन) की गणना करने के लिए एक कार्यक्रम लिखें और हमेशा की तरह, सबसे छोटा कोड जीतता है।

यहां आपके उपयोग के लिए एक छोटी सूची है। अधिक परीक्षण मामलों को A003418 के तहत OEIS में पाया जा सकता है ।

क्रमगुणित:

1
2
6
24
120
720
-5040

Pseudofactorial:

1
2
6
12
60
60
420

— टोनी रूथ
स्रोत

6

मुझे यकीन नहीं है कि मैं समझता हूं कि क्यों 2और 6कई गुना की सूची से हटा दिए गए थे। क्या आप नियमों को स्पष्ट कर सकते हैं?

— मैलेन्टेन

2

@ मैट्टीसेन, psuedofactorial (N) सबसे छोटी संख्या है जिसमें N के रूप में 1 कारक के रूप में संख्या है (उन संख्याओं के कम से कम सामान्य कई)। यह तकनीकी परिभाषा है, लेकिन जिस तरह से मैंने इसे लिखा था वह कुछ हद तक विचारोत्तेजक था कि यह एक तथ्य के समान है।

— टोनी रूथ

2

oeis.org/A003418

— नील

4

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यह एक अच्छी पहली चुनौती है!

— एलेक्स ए।

1

आपकी पहली चुनौती HNQ के शीर्ष पर पहुंच गई। अच्छा!

— डैनियल एम।

19

Dyalog एपीएल , 3 बाइट्स

∧/⍳

एपीएल ने जैली को हराया

⍳ 1 हालांकि तर्क

∧/ एलसीएम पार

— एडम
स्रोत

10

वो इंटरोबांग कितना सेक्सी है।

— शौकी

1

हे यार तुम डेनिस को हरा दो ...

— मामा फन रोल

1

प्रभावशाली, लेकिन ये 3 बाइट्स कैसे हैं ?

— को बंद करना बंद कर दिया

2

en.wikipedia.org/wiki/APL_(codepage)

— लीके नन

10

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

Ræl/

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

Ræl/  Main link. Input: n

R     Range; yield [1, ..., n].
   /  Reduce the range...
 æl     by LCM.

— डेनिस
स्रोत

8

सी (x86 के साथ), 52 बाइट्स

d(n,k,b,t){for(b=k=1;b;++k)for(t=n,b=0;t;b+=k%t--);}

1 से ऊपर की संख्या की जाँच करता है। प्रत्येक संख्या के लिए, इसे n से 1 से सभी संख्याओं में विभाजित करता है, और अवशेषों को जमा करता है। योग 0 होने पर रुक जाता है।

उपयोग:

main()
{
    printf("%d\n", d(7)); // outputs 420
}

यह स्पष्ट नहीं है कि यह एक मूल्य कैसे लौटाता है (कोई returnबयान नहीं है)।

X86 के लिए कॉलिंग सम्मेलन का कहना है कि फ़ंक्शन को eaxरजिस्टर में अपना मूल्य वापस करना होगा । आसानी से, विभाजन निर्देश में idivइसके इनपुट की उम्मीद है eax, और eax(भागफल) और edx(शेष) में परिणाम आउटपुट करता है । अंतिम पुनरावृत्ति kद्वारा विभाजित होती है 1, इसलिए eaxफ़ंक्शन से बाहर निकलने पर सही मान होगा।

यह केवल अनुकूलन पर काम करता है (डिबग-मोड में, यह आउटपुट 421)।

— anatolyg
स्रोत

आप n, k, b, और t के प्रकार की घोषणा नहीं करने के साथ कैसे दूर हो जाते हैं?

— टोनी रूथ

सी में डिफ़ॉल्ट-इंट नियम है - सभी लोप किए गए प्रकार intडिफ़ॉल्ट रूप से (रिटर्न मान सहित) हैं। यह फ़ंक्शन तर्कों के लिए काम करता है यदि उन्हें तथाकथित "पुरानी शैली" सिंटैक्स का उपयोग करके घोषित किया जाता है। स्पष्ट रूप से परिभाषित प्रकार के साथ घोषणा होगीint d(n,k,b,t) int n,k,b,t; {...}

— अनातोलीग

यदि आप एक कॉलिंग कन्वेंशन का लाभ ले रहे हैं, तो यह वास्तव में "C" के बजाय "C (cdecl)" चिह्नित होना चाहिए

— स्टीव कॉक्स

@SteveCox दोनों cdeclऔर stdcallवापसी-मूल्य के लिए एक ही विधि का उपयोग करते हैं, इसलिए मुझे लगता x86है कि पर्याप्त है

— anatolyg

7

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

f x=foldr1 lcm[1..x]

प्रयोग उदाहरण: map f [1..7]-> [1,2,6,12,60,60,420]।

lcmहास्केल में चाल।

— nimi
स्रोत

6

पायथन + सिम्पी, 45 बाइट्स

import sympy
lambda n:sympy.lcm(range(1,n+1))

काफी हद तक आत्म-व्याख्यात्मक।

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

i=r=input();exec't=r\nwhile r%i:r+=t\ni-=1;'*r;print r

Ideone पर इसका परीक्षण करें ।

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

इनपुट को वैरिएबल i और r में संग्रहित किया जाता है ।

execनिम्नलिखित कोड r बार निष्पादित करता है ।

t=r
while r%i:r+=t
i-=1

जबकि मैं से लेकर आर के 1 , हम की प्रारंभिक मूल्य जोड़ने आर (में संग्रहीत टी के रूप में) कई बार आवश्यक के रूप में करने के लिए आर खुद की एक बहु बनाने के लिए मैं । परिणाम है, जाहिर है, टी के एक बहु ।

R का अंतिम मान इस प्रकार रेंज [1, ..., n] में सभी पूर्णांकों का एक बहु है , जहां n इनपुट है।

— डेनिस
स्रोत

1

थर्ड पार्टी लाइब्रेरियों या execट्रिक्स का उपयोग किए बिना 78 बाइट समाधान है: from fractions import*;lambda n:reduce(lambda x,y:x*y/gcd(x,y),range(1,n+1),1) इस तथ्य का उपयोग करता है कि lcm(x,y) = x*y/gcd(x,y)।

— बकुरीउ

6

पायथन, 46 बाइट्स

g=lambda n,c=0:n<1or(c%n<1)*c or g(n,c+g(n-1))

कई के लिए खोज रहे cके g(n-1)सीधे। हालांकि मेरे पास पहले यह था कि यह विधि गलत तरीके से 0 को किसी भी चीज़ के रूप में पाएगी, लेकिन orशॉर्ट- सर्कुलेटिंग या (c%n<1)*cछोड़ देगी c==0क्योंकि 0 फाल्सी है।

50 बाइट्स:

g=lambda n,i=1:n<1or(i*n%g(n-1)<1)*i*n or g(n,i+1)

डेनिस के समाधान की तरह , लेकिन एक पुनरावर्ती कार्य के रूप में। परिकलित होने के बाद g(n-1), उनमें से सबसे छोटे गुणकों में i*nसे nएक के लिए भी दिखता है g(n-1)। वाकई धीमा।

के nबजाय के गुणकों को देखकर 4 बाइट्स के लिए डेनिस के लिए धन्यवाद g(n-1)।

— XNOR
स्रोत

5

जे, 9 बाइट्स

[:*./1+i.

सीधे-आगे का दृष्टिकोण। संख्या की सीमा बनाता है [0, ..., n-1], फिर प्रत्येक में एक जोड़ता है, और LCM का उपयोग करके इसे कम करता है।

प्रयोग

   f =: [:*./1+i.
   f 7
420

— मील की दूरी पर
स्रोत

5

MATL , 4 बाइट्स

:&Zm

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

व्याख्या

:      % Take input N implicitly. Generate range [1 2 ... N]
&Zm    % LCM of the numbers in that array. Display implicitly

— लुइस मेंडो
स्रोत

4

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

LCM@@Range@#&

— लीक नन
स्रोत

यह सिर्फ रचना LCMऔर Rangeसाथ के बराबर नहीं है @*?

— माल्टसेन

1

LCMसूची के आधार पर तत्व-वार संचालित करता है, जिसे पास किया जाएगा Range, जिसका अर्थ है कि केवल 1 से n के माध्यम से x के लिए lcm ( x ) लौटाएगा । इसके अलावा, एक लापता है जो अनाम फ़ंक्शन को बंद कर देगा। 13 बाइट्स के लिए कुछ ऐसा काम करेगा। &LCM@@Range@#&

— मील की दूरी पर

3

जूलिया, 11 बाइट्स

!n=lcm(1:n)

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

— डेनिस
स्रोत

3

पायथ - 8 बाइट्स

तब तक सभी नंबरों की जांच करता है जब तक कि वह एक ऐसा न मिल जाए जो विभाज्य है [1..N]।

f!s%LTSQ

टेस्ट सूट ।

— Maltysen
स्रोत

3

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

@(x)lcm(1,num2cell(1:x){:})

एक अनाम फ़ंक्शन बनाता है जिसे के रूप में लागू किया जा सकता है ans(N)।

ऑनलाइन डेमो

व्याख्या

यह समाधान के बीच सभी नंबरों की सूची बनाता है 1और x( 1:xके साथ एक सेल सरणी के लिए उन्हें), धर्मान्तरित num2cell। फिर {:}अनुक्रमण एक अल्पविराम से अलग की गई सूची बनाता है जिसे lcmकम से कम सामान्य एकाधिक की गणना करने के लिए कई इनपुट तर्कों के रूप में पारित किया जाता है। ए 1 को हमेशा पहले तर्क के रूप में पारित किया जाता है lcmक्योंकि lcmहमेशा कम से कम दो इनपुट तर्कों की आवश्यकता होती है।

— Suever
स्रोत

1

तो lcmऑक्टेव में 2 से अधिक इनपुट स्वीकार करता है! दिलचस्प

— लुइस मेंडू

@LuisMendo हाँ 2 +

— Suever

3

MATLAB, 49 बाइट्स

@(x)find(~any(bsxfun(@rem,1:prod(1:x),(1:x)')),1)

— Suever
स्रोत

+1 के लिएbsxfun

— 12

3

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

{[lcm] 1..$_}

अनाम कोड ब्लॉक जो 1 से इनपुट तक एक रेंज बनाता है (समावेशी), और फिर इसके साथ कम कर देता है &infix:<lcm>।

उदाहरण:

#! /usr/bin/env perl6
use v6.c;

my &postfix:<p!> = {[lcm] 1..$_}

say 1p!; # 1
say 2p!; # 2
say 3p!; # 6
say 4p!; # 12
say 5p!; # 60
say 6p!; # 60
say 7p!; # 420

say 10000p!; # 5793339670287642968692270879...
# the result from this is 4349 digits long

— ब्रैड गिल्बर्ट b2gills
स्रोत

ideone.com/gR4SK5

— ब्रैड गिल्बर्ट b2gills

2

जावास्क्रिप्ट (ईएस 6), 92 88 80 74 69 बाइट्स:

धन्यवाद @ConorOBrien और @ नील

y=>(g=(a,b)=>b?g(b,a%b):a,[...Array(y)].map((_,i)=>y=y*++i/g(y,i)),y)

— मोड़ना
स्रोत

b?g(b,a%b):aएक बाइट बचाता है।

— नील

y*++i/g(y,i)कुछ और बाइट्स बचाता है।

— नील

1

05AB1E, 20 बाइट्स

Lpvyi¹LÒN>¢àN>*ˆ}}¯P

व्याख्या

Lpv                    # for each item in isprime(range(1,N)): N=7 -> [0,1,1,0,1,0,1]
   yi                  # if prime
     ¹LÒN>¢            # count occurrences of the prime 
                         in the prime-factorization of range(1,N):
                         p=2 -> [0,1,0,2,0,1,0]
           àN>*ˆ       # add max occurrence of that prime multiplied by the prime 
                         to global array: N=7 -> [4,3,5,7]
                }}     # end if/loop
                  ¯P   # get product of global array

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

— Emigna
स्रोत

1

मिन्कोलांग 0.15 , 12 बाइट्स

मेरे पास दो 12-बाइट समाधान हैं, और उन दोनों को शामिल किया है।

1n[i1+4$M]N.

यहाँ कोशिश करो!

व्याख्या

1               Push 1
 n              Take number from input
  [             For loop that repeats n times
   i1+          Push loop counter + 1
      4$M       Pop b, a and push lcm(a,b)
         ]      Close for loop
          N.    Output as number and stop.

के रूप में के रूप में सीधे रूप में यह हो जाता है।

11nLd[4$M]N.

यहाँ कोशिश करो!

व्याख्या

11              Push two 1s
  n             Take number from input
   L            Pop b, a and push range from a to b, inclusive
    d           Duplicate top of stack (n)
     [4$M]      Pop b, a and push lcm(a,b), n times
          N.    Output as number and stop.

एक तीसरा समाधान इससे प्राप्त किया जा सकता है: एक को हटा दें 1और dवर्तमान के बाद जोड़ें d। दोनों ही मामलों में, अतिरिक्त संख्या की आवश्यकता होती है क्योंकि लूप के लिए कई बार एक चलता है, और इसे कम समय चलाने पर दो बाइट्स लगते हैं ( 1-ठीक पहले [)।

— एलेंडिया स्ट्राटन
स्रोत

1

रूबी, 25 बाइट्स

g=->n{(1..n).reduce :lcm}

रूबी, 25 बाइट्स

g=->n{n<1?1:a[n-1].lcm n}

— पीटर केगी
स्रोत

1

नमस्कार, और PPCG में आपका स्वागत है! महान पहली पोस्ट! आपको अपने फ़ंक्शन का नाम नहीं देना है, इसलिए आप निकाल सकते हैं g=।

— NoOneIsHere

बेनामी कार्यों की अनुमति है।

— आउटगॉल्फ

1

गेममेकर भाषा, 60 बाइट्स

for(b=k=1;b;++k){b=0for(t=argument0;t;b+=k mod t--)}return k

अनातोलीग उत्तर के तर्क के आधार पर।

— Timtech
स्रोत

1

PHP, 61 52 48 बाइट्स

सहेजे गए 9 बाइट्स @ user59178 के लिए धन्यवाद, लूप्स को मर्ज करके 4 बाइट्स।

PHP में पुनरावृत्ति functionकुंजी शब्द के कारण भारी है; इसलिए मैं पुनरावृत्ति का उपयोग करता हूं।
और एक "छोटे" कुछ ट्रिक्स के साथ, मैंने अब अरनौलड्स जेएस को भी हरा दिया ।

while(++$k%++$i?$i>$argv[1]?0:$i=1:$k--);echo$k;

कमांड लाइन तर्क से इनपुट लेता है। के साथ भागो -r।

टूट - फूट

while(++$k%++$i?    # loop $i up; if it does not divide $k
    $i>$argv[1]?0       # break if $i (smallest non-divisor of $k) is larger than input
    :$i=1               # while not, reset $i and continue loop with incremented $k
    :$k--);         # undo increment while $i divides $k
echo$k;         # print $k

ungolfed

यह वास्तव में एक में दो छोरों है:

while($i<=$argv[1]) # loop while $i (smallest non-divisor of $k) is not larger than input
    for($k++,       # loop $k up from 1
        $i=0;$k%++$i<1;);   # loop $i up from 1 while it divides $k
echo$k;             # print $k

नोट: डुप्लिकेट पर मेरे जवाब से कॉपी किया गया

— टाइटस
स्रोत

1

जाप, 10 बाइट्स

कोई एलसीएम बिल्ट-इन नहीं।

@õ e!vX}a1

कोशिश करो

— झबरा
स्रोत

0

पाइके, 3 बाइट्स, नॉनकमेटिंग

S.L

यहाँ कोशिश करो!

S   - range(1, input+1)
 .L - lowest_common_multiple(^)

— नीला
स्रोत

0

हून , 67 बाइट्स

|*
*
(roll (gulf 1 +<) |=({a/@ b/_1} (div (mul a b) d:(egcd a b))))

सूची बनाएँ [1..n], सूची के साथ lcm पर मोड़ें। दुर्भाग्य से, हून स्टडीलिब में एक पूर्व-निर्मित नहीं है जिसका मैं उपयोग कर सकता हूं: /

— RenderSettings
स्रोत

0

S, 7 चार्ट / 9 बाइट्स

Мū…⩤⁽1ï

Try it here (ES6 only).

1 से इनपुट तक समावेशी सीमा का सिर्फ एक LCM।

— मामा फन रोल
स्रोत

0

एडब्ल्यूके, 42 बाइट्स

{for(x=n=1;n<=$1;)if(x%n++){x++;n=1}$0=x}1

कमांड लाइन का उपयोग:

awk '{for(x=n=2;n<=$1;)if(x%n++){x++;n=2}$0=x}1' <<< NUM

मुझे कोई AWKहल नहीं मिला और प्रश्न का एक डुप्लिकेट कल ही पोस्ट किया गया था, इसलिए मैंने सोचा कि मैं इसे एक साथ फेंक दूंगा। यह बल्कि 19मेरे बॉक्स पर या उसके लिए बड़े धीमे हल है , लेकिन यह काम करता है।

— रॉबर्ट बेन्सन
स्रोत

0

QBIC , 35 32 बाइट्स

यह मुझे यहां लाया।

:{p=0[a|~q%b|p=1]]~p=0|_Xq\q=q+1

स्पष्टीकरण:

:        Get cmd line param as number 'a'
{        Start an infinite DO loop
p=0      Sets a flag that shows if divisions failed
[a|      FOR (b=1; b<=a; b++)
~q%b     IF 'q' (which starts at 1 in QBIC) is not cleanly divisible by 'b'
|p=1     THEN Set the flag
]]   Close the FOR loop and the IF, leave the DO open
~p=0     IF 'q' didn't get flagged
|_Xq     THEN quit, printing 'q'
\q=q+1   ELSE raise 'q', redo
         [DO Loop implicitly closed by QBIC]

यहाँ एक संस्करण है जो परीक्षण को रोक देता है qजब bवह सफाई से विभाजित नहीं करता है। इसके अलावा, परीक्षण के आदेश bके खिलाफ qइस धारणा में उलट है कि उच्च bका विभाजन करने के लिए कठिन से हो जाएगा (ले 2, 3, 4उदाहरण के लिए: अगर %2=0, %4हो सकता है !0। वाइस विपरीत नहीं इतना ...)।

:{p=0[a,2,-1|~q%b|p=1┘b=2]]~p=0|_Xq\q=q+1

— steenbergh
स्रोत

0

Axiom, 35 बाइट्स

f(x)==reduce(lcm,[i for i in 1..x])

परीक्षण कोड और परिणाम

(25) -> [[i,f(i)] for i in [1,6,19,22,30]]
   (25)  [[1,1],[6,60],[19,232792560],[22,232792560],[30,2329089562800]]
                                                  Type: List List Integer

मैं सिर्फ सबसे छोटे धनात्मक पूर्णांक का पता लगाता हूँ, जिसमें 1 से n तक के सभी पूर्णांक हैं, क्योंकि कारक कहते हैं कि यह कहते हैं कि मैं इसे यहाँ पोस्ट कर रहा हूँ

— RosLuP
स्रोत

0

परी / जीपी , 14 बाइट्स

n->lcm([1..n])

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

— alephalpha
स्रोत

0

8 वें , 23 बाइट्स

कोड

1 ' lcm rot 2 swap loop

इस कोड से टीओएस पर स्यूडोफैक्टीरियल निकलता है

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

ok> 7 1 ' lcm rot 2 swap loop .
420

या अधिक स्पष्ट रूप से

ok> : pseudofact 1 ' n:lcm rot 2 swap loop ;

ok> 7 pseudofact .
420

— अराजकता मनोर
स्रोत