บางครั้งเมื่อฉันพยายามที่จะแยกแยะตัวเลขใด ๆ ที่ปรากฏขึ้นต่อหน้าฉันอย่างเฉยๆหลังจากนั้นไม่นานฉันก็รู้ว่ามันง่ายกว่าที่ฉันคิด ใช้2156ตัวอย่างเช่น: ในที่สุดมันก็เกิดขึ้นกับผมว่าทั้งสอง21และ56มีหลายรายการ7และอื่น ๆ อย่างแน่นอน2156 = 21 x 100 + 56นอกจากนี้ยังมีหลาย7นอกจากนี้ยังมีหลาย

งานของคุณคือการเขียนโค้ดที่ระบุตัวเลขที่ง่ายกว่าในการแยกตัวประกอบเนื่องจากความบังเอิญของการเรียงลำดับนี้

อย่างแม่นยำมากขึ้น:

เขียนโปรแกรมหรือฟังก์ชั่นที่ใช้เป็นจำนวนเต็มบวกnเป็น input และผลตอบแทนที่คุ้มค่า truthy ถ้ามีอยู่ตัวหารd(มากกว่า1) ดังกล่าวว่าnสามารถสับในสองให้ผลผลิตจำนวนเต็มบวกซึ่งแต่ละมีหลายd; ส่งคืนค่าเท็จถ้าไม่

• "สับเป็นสองชิ้น" หมายถึงสิ่งที่คุณคิด: การเป็นตัวแทนพื้นฐาน 10 ของการ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

¹ใช่ฉันทำสิ่งนี้จริงๆ

เรติน่า , 31 29 ไบต์

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

ลองออนไลน์!

ส่งออกจำนวนเต็มบวกสำหรับอินพุตที่ถูกต้องและศูนย์สำหรับรายการที่ไม่ถูกต้อง

ฉันจะไม่แนะนำให้รอกรณีทดสอบขนาดใหญ่ ...

คำอธิบาย

,$';$`

ที่แต่ละตำแหน่งของการใส่เครื่องหมายจุลภาคแล้วทุกอย่างก่อนที่ตำแหน่งนั้นแล้วเครื่องหมายอัฒภาคแล้วทุกอย่างหลังจากตำแหน่งนี้ มันทำอะไร มันทำให้เรามีตัว,คั่นที่เป็นไปได้ทั้งหมดของตัวเลข (แยกด้วยคั่นด้วย;) แล้วใส่อีกครั้งในตอนท้าย ดังนั้นการป้อนข้อมูล123จะกลายเป็น

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

ที่ซึ่งฉันได้ทำเครื่องหมายอักขระป้อนข้อมูลดั้งเดิม (สิ่งที่ไม่ได้ทำเครื่องหมายคือสิ่งที่เราแทรกไว้) โปรดทราบว่าสิ่งนี้จะสร้างตัวแยกที่ไม่ถูกต้องซึ่งไม่ใช่ตัวแยกส่วนที่เกิดขึ้นจริงและมันก็ไม่สนใจว่าองค์ประกอบต่อท้ายเป็นศูนย์ทั้งหมด แต่เราจะหลีกเลี่ยงการยอมรับในภายหลัง ประโยชน์ของการสร้างตัวแยกที่ไม่ถูกต้องคือเรารู้ว่าการแยกที่ถูกต้องแต่ละครั้งจะมี;ด้านหน้าและหลังดังนั้นเราจึงสามารถบันทึกสองไบต์บนขอบเขตของคำ

\d+
$*

แปลงแต่ละหมายเลขเป็นเอก

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

จับคู่การแยกโดยจับคู่ทั้งสองครึ่งให้เป็นทวีคูณของตัวเลขบางอย่างที่อย่างน้อย 2

Brachylog (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.หากเส้นทางทั้งหมดนำไปสู่ความล้มเหลว นั่นคือสิ่งที่เราต้องการที่นี่

เยลลี่ , 14 12 11 10 ไบต์

ŒṖḌo1g/€P>

ขอบคุณ @JonathanAllan สำหรับการตีกอล์ฟ 1 ไบต์!

ลองออนไลน์!

มันทำงานอย่างไร

ŒṖḌ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.

Mathematica, 63 62 ไบต์

(1 ไบต์ขอบคุณ Greg Martin)

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

มันเป็นฟังก์ชั่นที่ใช้เป็นจำนวนเต็มเป็น input และผลตอบแทนหรือTrue Falseหากคุณทดสอบเป็นจำนวนมากนำหนังสือมาอ่านในขณะที่คุณรอ

คำอธิบาย:

• Floor@{Mod[#,t=10^n],#/t}arithmetically แยกอินพุตเป็นnตัวเลขสุดท้ายและตัวเลขที่เหลือm-n(ซึ่งmเป็นจำนวนรวมของตัวเลข)
• Table[1~Max~#&/@...,{n,#}]ทำเช่นนี้สำหรับทุก ๆnจนถึงหมายเลขอินพุต (นี่เป็นวิธีที่ใหญ่เกินไปเราต้องทำตามจำนวนหลักของอินพุตเท่านั้น แต่วิธีนี้จะช่วยประหยัดไบต์และยังให้ผลลัพธ์ที่ถูกต้องด้วย) 1~Max~#&/@บิตจะถูกกำจัดเป็นศูนย์ดังนั้นตัวเลขเช่น130 -> {13,0}ไม่นับ Trueในขณะที่
• 1<Max@@GCD@@@... ค้นหาตัวหารสามัญที่ยิ่งใหญ่ที่สุดของแต่ละคู่เหล่านี้และตรวจสอบว่าตัวหารใด ๆ เหล่านี้มากกว่า 1 หรือไม่ถ้าใช่เราพบวิธีแยกตัวประกอบจำนวนด้วยการแยก

Haskell , 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

C, 145 142 139 138 135 ไบต์

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;}

JavaScript (ES6), 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>

ใช้อินพุตเป็นสตริงซึ่งเป็นประโยชน์สำหรับตัวอย่าง แก้ไข: บันทึกแล้ว 3 ไบต์ด้วย @ user81655

Python 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)ตามค่าบูลีน Python เริ่มต้น
-3 ไบต์ขอบคุณ Dead Possum
-15 ไบต์ขอบคุณ ovs
-1 ไบต์ขอบคุณ Guy นี้

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

Python 3 , 70 69 ไบต์

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

ลองออนไลน์!

Perl 5 , 46 ไบต์

43 ไบต์ของรหัส + 3 ไบต์สำหรับการ-pตั้งค่าสถานะ

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

ลองออนไลน์! หรือลองใช้เวอร์ชันที่แก้ไขนี้ซึ่งอนุญาตให้มีอินพุตหลายอินพุต
คุณอาจไม่ต้องการลองสิ่งนี้กับอินพุตที่ใหญ่ที่สุดเนื่องจากอาจใช้เวลา (นานมาก) ในขณะที่

คำอธิบาย:
เราวนซ้ำแต่ละตำแหน่งในคำด้วยs~~~gโดย$`มีตัวเลขก่อนและ$'หลัง หาก$`*$'เป็นจริง (หมายความว่าไม่มีค่าว่างและไม่มี0) เราจะตรวจสอบว่ามีตัวเลขระหว่าง 2 และ$`หารทั้งสองด้วย (ด้วยgrep!(...),2..$`) หรือไม่ ถ้าเป็นเช่นนั้น$\|=..จะตั้งค่า$\ที่ไม่เป็นศูนย์ซึ่งจะถูกพิมพ์โดยปริยายในตอนท้ายด้วยการ-pตั้งค่าสถานะ

Python 2 , 69 ไบต์

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)

ใช้การเรียกซ้ำแทนการใช้ GCD ในตัว

ลองออนไลน์!

มันทำงานอย่างไร

เมื่อfถูกเรียกโดยมีอาร์กิวเมนต์หนึ่งถึงสามอาร์กิวเมนต์ ( ค่าเริ่มต้นdเป็น10 , kถึง2 ) จะตรวจสอบค่าของนิพจน์k<d<nก่อน หากความไม่เท่าเทียมกันk <dและd <nทั้งคู่พักการแสดงออกต่อไปนี้andได้รับการดำเนินการและความคุ้มค่าของมันจะถูกส่งกลับ; มิฉะนั้นฉก็จะกลับเท็จ

n/d%k+n%d%k<1<n%dในกรณีที่อดีตเราเริ่มต้นด้วยการประเมินการแสดงออก

dจะเป็นพลังของสิบเสมอn/dและn%dแยกทศนิยมในnเป็นสองส่วนอย่างมีประสิทธิภาพ ชิ้นส่วนเหล่านี้สามารถหารได้ด้วยkถ้าหากn/d%k+n%d%kประเมินเป็น0เท่านั้นซึ่งจะถูกทดสอบโดยการเปรียบเทียบผลลัพธ์ด้วย 1

เนื่องจากเป็นส่วนหนึ่งของความต้องการคือการที่ทั้งสองชิ้นจะต้องเป็นตัวแทนของจำนวนเต็มบวกค่าของn%dยังเทียบกับ1 โปรดทราบว่า1ไม่มีตัวคั่นหลักดังนั้นจึงไม่จำเป็นต้องเปรียบเทียบราคาที่แพงกว่ากับ0 นอกจากนี้โปรดทราบว่าd <nมั่นใจแล้วว่าn/dจะประเมินเป็นจำนวนเต็มบวก

ในที่สุดมันจะเรียกซ้ำทั้งหมดf(n,d,k+1)(ลองใช้ตัวหารร่วมที่มีศักยภาพต่อไป) และf(n,10*d)(พยายามแยก) และส่งกลับตรรกะหรือผลลัพธ์ทั้งสามรายการ ซึ่งหมายความฉจะกลับมาทรูถ้า (และถ้ามี) kเป็นตัวหารร่วมกันของn / dและn% dหรือเดียวกันเป็นความจริงสำหรับค่าขนาดใหญ่ของkและ / หรือพลังงานที่สูงขึ้นสิบd