फूट डालो और राज करो

Question

कभी-कभी, जब मैं निष्क्रिय रूप से कारक की कोशिश कर रहा होता हूं, जो भी संख्या मेरे सामने आती है, तो थोड़ी देर बाद मुझे एहसास होता है कि मैंने जितना सोचा था, यह उतना आसान है। 2156उदाहरण के लिए ले लो : यह अंततः मेरे लिए होता है कि दोनों 21और के 56गुणक हैं 7, और इसलिए निश्चित रूप 2156 = 21 x 100 + 56से भी एक से अधिक है 7।

आपका कार्य कुछ कोड लिखना है जो उन संख्याओं की पहचान करता है जो इस प्रकार के संयोग के कारण कारक के लिए आसान हैं।

ज्यादा ठीक:

एक प्रोग्राम या फ़ंक्शन लिखें जो nइनपुट के रूप में एक सकारात्मक पूर्णांक लेता है , और एक सत्य मान देता है यदि कोई विभाजक d(अधिक से अधिक 1) मौजूद है जैसे कि nदो सकारात्मक पूर्णांक बनाने के लिए दो में कटा हुआ हो सकता है, जिनमें से प्रत्येक एक से अधिक है d; यदि नहीं तो एक मिथ्या मूल्य लौटाएं।

• "दो में कटा हुआ" का अर्थ है कि आप क्या सोचते हैं: nकिसी भी बिंदु पर विभाजित किए गए सामान्य आधार -10 का प्रतिनिधित्व सामने के आधे हिस्से में और पीछे के आधे हिस्से में दो अन्य आधार -10 पूर्णांकों का उत्पादन होता है। यह ठीक है अगर दूसरे पूर्णांक एक अग्रणी शून्य (लेकिन ध्यान दें कि यह एक सकारात्मक पूर्णांक होना चाहिए, इसलिए बंटवारे है 1230में 123और 0मान्य नहीं है)।
• सत्य और मिथ्या मूल्य इनपुट पर निर्भर कर सकते हैं। उदाहरण के लिए, यदि आपकी पसंद की भाषा में कोई भी गैर-पूर्णांक सत्य है, तो आप भाजक dया उस चीज़ के "टुकड़ों" n(या nस्वयं) में से एक का वापस करने के लिए स्वागत करते हैं ।
• उदाहरण के लिए, सेट में कम से कम दो अंकों के साथ कोई भी संख्या {2, 4, 6, 8}एक सत्य मान देगी: बस इसे पहले अंक के बाद भी विभाजित करें। उदाहरण के लिए, किसी भी अभाज्य संख्या में nएक गलत मान होगा, जैसे कि कोई भी एक-अंकीय संख्या।
• ध्यान दें कि यह प्रधान विभाजकों पर विचार करने के लिए पर्याप्त है d।
• आप मान सकते हैं कि इनपुट वैध है (जो कि एक धनात्मक पूर्णांक है)।

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है। लेकिन सभी भाषाओं में समाधान स्वागत योग्य हैं, इसलिए हम प्रत्येक भाषा में सबसे छोटे कोड के लिए प्रयास कर सकते हैं, न कि केवल सबसे छोटे कोड के लिए।

परीक्षण के मामलों

(आपको केवल एक सत्य या मिथ्या मूल्य का उत्पादन करना होगा; नीचे दिए गए एनोटेशन स्पष्टीकरण के माध्यम से हैं।) कुछ इनपुट जो सत्य मानों को उत्पन्न करते हैं:

39  (3 divides both 3 and 9)
64  (2 divides both 6 and 4)
497  (7 divides both 49 and 7)
990  (splitting into 99 and 0 is invalid; but 9 divides both 9 and 90)
2233  (11 divides both 22 and 33)
9156  (3 divides both 9 and 156; or, 7 divides both 91 and 56)
11791  (13 divides both 117 and 91)
91015  (5 divides both 910 and 15)
1912496621  (23 divides both 1912496 and 621; some splittings are multiples of 7 as well)
9372679892  (2473 divides both 937267 and 9892; some splittings are multiples of 2 as well)

झूठा मान देने वाले कुछ इनपुट हैं:

52
61
130  (note that 13 and 0 is not a valid splitting)
691
899
2397
9029
26315
77300  (neither 7730 and 0 nor 773 and 00 are valid splittings)
2242593803

Do हां मैं वास्तव में ऐसा करता हूं

Answer 1

रेटिना , 31 29 बाइट्स

,$';$`
\d+
$*
;(11+)\1*,\1+;

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

वैध इनपुट्स के लिए एक सकारात्मक पूर्णांक और अमान्य लोगों के लिए शून्य आउटपुट करता है।

मैं बड़े परीक्षण मामलों की प्रतीक्षा करने की अनुशंसा नहीं करूंगा ...

व्याख्या

,$';$`

इनपुट की प्रत्येक स्थिति में अल्पविराम सम्मिलित करें, फिर उस स्थिति से पहले सब कुछ, फिर अर्धविराम, फिर इस स्थिति के बाद सब कुछ। वह क्या करता है? यह हमें एक संख्या के सभी संभावित विभाजन देता है (द्वारा विभाजित), , द्वारा अलग ;), और फिर अंत में फिर से इनपुट। तो इनपुट 123बन जाता है

,123;1,23;12,3;123,;123
     ^     ^     ^

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

\d+
$*

प्रत्येक संख्या को एकात्मक में बदलें।

;(11+)\1*,\1+;

कम से कम 2 है कि कुछ संख्या के गुणकों के रूप में दोनों हिस्सों से मिलान करके एक बंटवारे का मिलान करें।

Comments

रेटिना के बारे में त्वरित प्रश्न: अग्रणी नईलाइन क्या करती है?

— हाइपरन्यूट्रीनो

@HyperNeutrino अच्छी तरह से पहली पंक्ति है जो हम मैच करते हैं, और हम पात्रों के बीच हर एक स्थिति में प्रतिस्थापन सम्मिलित करने के लिए, खाली rexx का मिलान करना चाहते हैं।

— मार्टिन एंडर

ओह ठीक है। धन्यवाद! मुझे शायद रेटिना पर थोड़ा और देखना चाहिए; चूंकि यह मोटे तौर पर रेगेक्स आधारित लगता है, इसलिए यह कोलमोगोरोव-जटिलता समस्याओं के लिए अच्छा हो सकता है।

— हाइपरन्यूट्रिनो

अंतिम पंक्ति हो सकती है;(11+)+,\1+;

— रिले

@ रिले जो कि गारंटी नहीं देता है कि पहला खंड एक ही कारक का एक बहु है।

— मार्टिन एंडर

Answer 2

ब्रेकीलॉग (2), 8 बाइट्स

~c₂ḋᵐ∋ᵐ=

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

व्याख्या

~c₂ḋᵐ∋ᵐ=
~c₂       Split the input into two pieces
    ᵐ ᵐ   On each of those pieces:
   ḋ ∋      Choose a prime factor
       =  such that both the chosen factors are equal

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

आंतरिक जीरो मिलान के खिलाफ जांच करने की कोई आवश्यकता नहीं है; यदि विभाजित है xऔर 0yमान्य है, x0और yठीक वैसे ही काम करेगा (और दूसरे तरीके से जा रहा है, यदि x0और yकाम करता है, तो हमारे पास एक कार्यशील समाधान है चाहे वह xऔर हो0y काम करते हैं या नहीं)।

इस तरह की एक Brachylog पूर्ण कार्यक्रम, एक बूलियन लौटाता है; true.अगर असफलता के बिना इसे चलाने का कोई तरीका है (जैसे कि कोई विकल्प नहीं होता है तो कोई त्रुटि नहीं होती है), false.यदि सभी रास्ते विफल हो जाते हैं। ठीक यही हम यहाँ चाहते हैं।

Answer 3

जेली , 14 12 11 10 बाइट्स

ŒṖḌo1g/€P>

1 बाइट को बंद करने के लिए @JonathanAllan को धन्यवाद!

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

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

ŒṖḌo1g/€P>  Main link. Argument: n

ŒṖ          Compute all partitions of n's decimal digits.
  Ḍ         Undecimal; convert each array in each partition back to integer.
   o1       OR 1; replace disallowed zeroes with ones.
     g/€    Reduce (/) each (€) partition by GCD (g).
            The last GCD corresponds to the singleton partition and will always be
            equal to n. For a falsy input, all other GCDs will be 1.
        P   Take the product of all GCDs.
         >  Compare the product with n.

Comments

मुझे लगता है कि आप इसे छोड़ सकते हैं D, जैसा make_digitsकि इसके प्रभाव में है ŒṖ।

— जोनाथन एलन

किसी कारण के लिए, मैंने मान लिया कि एक सीमा बनाई जाएगी ... धन्यवाद!

— डेनिस

Answer 4

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

(ग्रेग मार्टिन के लिए 1 बाइट)

1<Max@@GCD@@@Table[1~Max~#&/@Floor@{Mod[#,t=10^n],#/t},{n,#}]&

यह एक फ़ंक्शन है जो इनपुट और रिटर्न के रूप में पूर्णांक लेता है TrueयाFalse । यदि आप बड़ी संख्या में इसका परीक्षण करते हैं, तो प्रतीक्षा करते समय पढ़ने के लिए एक पुस्तक लाएँ।

स्पष्टीकरण:

• Floor@{Mod[#,t=10^n],#/t}अंकगणित इनपुट को उसके अंतिम nअंकों और शेष m-nअंकों (जहां अंकों mकी कुल संख्या है) में विभाजित करता है ।
• Table[1~Max~#&/@...,{n,#}]यह nइनपुट नंबर तक प्रत्येक के लिए करता है। (यह रास्ता बहुत बड़ा है। हमें केवल इनपुट के अंकों की संख्या तक ऐसा करने की आवश्यकता है , लेकिन यह तरीका बाइट्स को बचाता है और फिर भी सही परिणाम देता है।) 1~Max~#&/@बिट को शून्य से छुटकारा मिलता है, इसलिए संख्याओं की 130 -> {13,0}गणना नहीं होती है। के रूप में True।
• 1<Max@@GCD@@@... इनमें से प्रत्येक जोड़े का सबसे बड़ा सामान्य भाजक पाता है, और जाँचता है कि क्या इनमें से कोई भी भाजक 1 से अधिक नहीं है। यदि वे हैं, तो हमने इसे विभाजित करके संख्या को कारक करने का एक तरीका खोजा है।

Comments

अच्छा जवाब! आप {#~Mod~10^n,#/10^n}या तो के साथ एक बाइट बचा सकते हैं {Mod[#,t=10^n],#/t}।

— ग्रेग मार्टिन

मैंने कोशिश की #~Mod~10^n, लेकिन ऐसा लगता है कि Mod[#,10]^nइसके बजाय ब्रैकेटेड हो गया है Mod[#,10^n]। मैं हालांकि अपने दूसरे सुझाव के बारे में नहीं सोचा था!

— पेड़ नहीं

निष्पक्ष बिंदुMod[#,10]^n

— ग्रेग मार्टिन

Answer 5

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

x#n|b<-mod x n=x>n&&(b>0&&gcd(div x n)b>1||x#(10*n))
(#1)

इसे ऑनलाइन आज़माएं! उपयोग: (#1) 2156रिटर्नTrue याFalse

Answer 6

सी, 145 142 139 138 138 बाइट्स

i,a,b;f(){char s[99];scanf("%s",s);for(char*p=s;*p++;)for(b=atoi(p),i=*p,*p=0,a=atoi(s),*p=i,i=1;i++<b;)*s=a%i-b%i|b%i?*s:0;return!*s;}

Answer 7

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

f=(s,t='',u)=>u?s%t?f(t,s%t,1):t:s&&f(t+=s[0],s=s.slice(1),1)>1|f(s,t)

<input oninput=o.textContent=f(this.value)><span id=o>

इनपुट को एक स्ट्रिंग के रूप में लेता है, जो स्निपेट के लिए आसान है। संपादित करें: @ उपयोगकर्ता81655 के लिए 3 बाइट्स का धन्यवाद सहेजा गया।

Comments

दो बाइट्स बचाता है: (c,i)-> c, i+1-> ++i, t=''-> i=t='', यह ट्रिक किसी भी समय उपयोगी है जब आपको 1-आधारित सूचकांकों का उपयोग करने की आवश्यकता होती है और इसे शुरू iकरने के लिए कहीं होना चाहिए 0।

— user81655

इसके अलावा, मेरा मानना ​​है कि t=''हो सकता है t=0, क्योंकि cयह एक तार करने के लिए वैसे भी coerces जोड़ने ।

— user81655

@ user81655 यह इसलिए हुआ क्योंकि मैं मूल रूप से कटा हुआ था और iइसलिए, मुझे 1-आधारित सूचकांकों की आवश्यकता नहीं थी, लेकिन फिर मैंने पहली स्लाइस को गॉल्फ़ किया t+=c।

— नील

आह अच्छा। इसके अलावा एक आखिरी बात, मुझे लगता है कि यह एक पुनरावर्ती कार्य के रूप में भी छोटा हो सकता है f=(x,y,z)=>z?x%y?g(y,x%y):y:x?f(x,y,1)>1||f(x.slice(1),~~y+x[0]):0:। मैंने आपके GCD फ़ंक्शन fको भी साथ जोड़ दिया । शायद आगे गोल्फ हो सकता है। आखिरी सुझाव, मैं वादा करता हूँ! : पी

— user81655

@ user81655 दुख की बात है कि मेरा ओवरसाइप्लाइज़्ड gcdफंक्शन तब काम नहीं करता है x=0, और उसके आसपास काम करना और आपका टाइपो मुझे 72 बाइट्स में ले जाता है, इसलिए यह सौभाग्य की बात है कि मैं तब 2 बाइट्स से दूर था।

— नील

Answer 8

पायथन 3, 133 118 117 बाइट्स

i,j=int,input()
from fractions import*
print(any(i(j[k:])*i(j[:k])*~-gcd(i(j[k:]),i(j[:k]))for k in range(1,len(j))))

निश्चित रूप से सबसे छोटा नहीं, शायद थोड़ा छोटा किया जा सकता है। O(n)समय में काम करता है । इनपुट प्रारूप में लिया जाता है \d+और आउटपुट (True|False)डिफ़ॉल्ट रूप में दिया जाता है, जैसे कि पायथन बूलियन मान
-3 बाइट्स के लिए धन्यवाद डेड
पोसुम -15 बाइट्स के लिए धन्यवाद, अंडा
-1 इस बाइट के लिए धन्यवाद

Comments

from fractions import*3 बाइट्स बचाएगा

— डेड पॉसम

यह 900 के लिए सही है। मुझे लगता है, यह गलत है। एमबी आप आंतरिक बदलना चाहिए anyकरने के लिए all? अगर ऐसा है, तो आप i(j[k:])and i(j[:k])सभी को 125 बाइट्स में लाने के लिए उस हिस्से को बदल सकते हैं । यहाँ फ़िक्स हैं

— डेड पोसुम

आप गुणन द्वारा और सभी को प्रतिस्थापित कर सकते हैं:any(i(j[k:])*i(j[:k])*~-gcd(i(j[k:]),i(j[:k]))for k in range(1,len(j)))

— ovs

@DeadPossum ओह ठीक है, मुझे ऐसा करना चाहिए था। और हाँ, मेरी वर्तमान पद्धति में बहुत सारे गोल्फ वाले हिस्से हैं, लेकिन मैं ओवस के सुझावों का पालन करने जा रहा हूं। यह बात बताने के लिए धन्यवाद! (वास्तव में इसे स्वयं परीक्षण करना चाहिए था ... ओह अच्छी तरह से ...)

— हाइपरनेट्रिनो

आप एक बाइट (लगभग कुछ भी नहीं) के बीच )) for

— व्हाट्सएप

Answer 9

QBIC , 91 90 बाइट्स

;_LA|[a-1|B=left$(A,b)┘C=right$(A,a-b)┘x=!B!┘y=!C![2,x|~(x>1)*(y>1)*(x%c=0)*(y%c=0)|_Xq}?0

स्पष्टीकरण:

;               Get A$ from the command prompt
_LA|            Get the length of A$ and place it in a% (num var)
[a-1|           for b%=1; b% <= a%-1; b%++
B=left$(A,b)    break A$ in two components on index b%
C=right$(A,a-b)
x=!B!┘y=!C!     Convert both parts from string to num, assign to x% and y%
[2,x|           FOR c% = 2; c% <= x%; c%++

This next IF (~ in QBIC) is a bit ... iffy. It consists of a set of comparators.
Each comparator yields a -1 or a 0. We take the product of these. At any failed
comparison this will yield 0. When successful, it yields 1, which is seen as true by QBasic.

~(x>1)*(y>1)        IF X>1 and Y>1 --> this stops '00' and '1' splits.
*(x%c=0)*(y%c=0)    Trial divide the splits on loop counter c%.

|_Xq            Success? THEN END, and PRINT q (which is set to 1 in QBIC)
}               Close all language constructs (2 FOR loops and an IF)
?0              We didn't quit on match, so print 0

Answer 10

Python 3, 70 69 bytes

import math
f=lambda n,d=1:n>d and n%d*~-math.gcd(n//d,n%d)+f(n,10*d)

Try it online!

Answer 11

Perl 5, 46 bytes

43 bytes of code + 3 bytes for -p flag.

s~~$\|=grep!($`%$_|$'%$_),2..$`if$`*$'~ge}{

Try it online! or try this modified version allowing multiple inputs.
You probably don't want to try this on the largest input, as it might take a (very long) while.

Explanations:
We iterate through each position in the word with s~~~g, with $` containing the numbers before and $' the numbers after. If $`*$' is true (it means that none is empty, and none is 0), then we check if a number between 2 and $` divides both of them (with the grep!(...),2..$`). If so, $\|=.. will set $\ to a non-zero value, which is implicitly printed at the end thanks to -p flag.

Comments

If anyone knows how to render a $<backquote> in SE markdown, I'd be grateful if you tell me how.

— Dada

You can do it via using explicit <code> … </code> (rather than ` … `), then escaping the backquotes as \`. Also, this comment was a pain to write, because it has to be double-escaped (and the two sets of escaping rules are different!).

@ais523 Wonderful, thank you very much! :)

— Dada

Answer 12

Python 2, 69 bytes

f=lambda n,d=10,k=2:k<d<n and(n/d%k+n%d%k<1<n%d)|f(n,d,k+1)|f(n,10*d)

Uses recursion instead of GCD built-ins.

Try it online!

How it works

When f is called with one to three arguments (d defaults to 10, k to 2), it first checks the value of the expression k<d<n. If the inequalities k < d and d < n both hold, the expression following and gets executed and its value is returned; otherwise, f will simply return False.

In the former case, we start by evaluating the expression n/d%k+n%d%k<1<n%d.

d will always be a power of ten, so n/d and n%d effectively split the decimal digits on n into two slices. These slices are both divisible by k if and only if n/d%k+n%d%k evaluates to 0, which is tested by comparing the result with 1.

Since part of the requirements is that both slices must represent positive integers, the value of n%d is also compared with 1. Note that 1 has no prime divisors, so the more expensive comparison with 0 is not required. Also, note that d < n already ensures that n/d will evaluate to a positive integer.

Finally it recursively all f(n,d,k+1) (trying the next potential common divisor) and f(n,10*d) (trying the splitting) and returns the logical OR of all three results. This means f will return True if (and only if) k is a common divisor of n/d and n%d or the same is true for a larger value of k and/or a higher power of ten d.