จำนวนเต็มที่น้อยที่สุดหลังจาก N หารด้วย 2, 3 และ 4


22

ให้เครดิตกับผู้ที่เป็นเครดิตเนื่องจาก

วัตถุประสงค์ป.ร. ให้ไว้เป็นจำนวนเต็มN > 0ออกเลขที่เล็กที่สุดA, BและCเพื่อที่:

  1. ทั้งหมดจากA, BและCเข้มงวดมากกว่าN;
  2. 2หารA;
  3. 3หารB;
  4. และแบ่ง4C

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ คุณสามารถใช้ภาษาที่สร้าง / อัปเดตหลังจากความท้าทายนี้ แต่ไม่ได้แข่งขันอย่างเคร่งครัด

กรณีทดสอบ

N => A, B, C
1 => 2, 3, 4
4 => 6, 6, 8
43 => 44, 45, 44
123 => 124, 126, 124
420 => 422, 423, 424
31415 => 31416, 31416, 31416
1081177 => 1081178, 1081179, 1081180

เราสามารถส่งออกผลลัพธ์ในลำดับที่แตกต่างกัน (เช่นC B A) ถ้ามันระบุไว้อย่างชัดเจนในคำตอบหรือไม่
Martin Ender

@ MartinBüttnerที่เป็นที่ยอมรับ
Conor O'Brien

คำตอบ:


17

เยลลี่ขนาด 8 ไบต์

~%2r4¤+‘

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

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

~%2r4¤+‘  Main link. Argument: n (integer)

~         Bitwise NOT; yield ~n = -(n + 1).
     ¤    Combine the three links to the left into a niladic chain:
  2         Yield 2.
   r4       Yield the range from 2 to 4, i.e., [2, 3, 4].
 %        Yield the remainder of the division of ~n by 2, 3 and 4.
          In Python/Jelly, -(n + 1) % k = k - (n + 1) % k if n, k > 0.
       ‘  Yield n + 1.
      +   Add each modulus to n + 1.

26

Python 2, 32 ไบต์

lambda n:[n+2&-2,n/3*3+3,n+4&-4]

Bit เลขคณิตสำหรับ 2 และ 4, เลขคณิตแบบแยกส่วนสำหรับ 3

ฉันพบนิพจน์ขนาด 7 ไบต์สี่ตัวสำหรับการคูณkด้านบนnแต่ไม่สั้นกว่านี้:

n-n%k+k
~n%k-~n
n/k*k+k
~n/k*-k

ใด ๆ ให้ 34 ไบต์เมื่อคัดลอกk=2,3,4และ 33 ไบต์หากรวมกัน:

[n/2*2+2,n/3*3+3,n/4*4+4]
[n/k*k+k for k in 2,3,4]

แต่ 2 และ 4 เป็นพลังของ 2 ที่อนุญาตให้บิตเล็ดรอดจากศูนย์ 1 หรือ 2 ไบต์สุดท้าย

n+2&-2
n+4&-4

นี้จะช่วยให้ 6 ไบต์ (แทน 7) สำหรับการเดินทางหลายต่อไปสำหรับ 32 for k in 2,3,4ไบต์โดยรวมตี

น่าเสียดายที่การคาดการณ์n|1+1และn|3+1ทำการเพิ่มก่อนดังนั้นการเพิ่มเอาท์พุทจึงต้องใช้วงเล็บ


1
n+k-n%kในสายพันธุ์ที่เป็นไปได้ตั้งค่าของฉันคือ
Neil

ไม่n&3+1ทำนอกจากแรกเกินไป?
ทิม

@ Tim Yup เหมือนกับการดำเนินการบูลีนทั้งหมด
xnor


12

MATL, 15 10 9 ไบต์

2:4+t5M\-

ลองออนไลน์!

คำอธิบาย:

2:4          #The array [2, 3, 4]
   +         #Add the input to each element, giving us [12, 13, 14]
    t        #Duplicate this array
     5M      #[2, 3, 4] again
       \     #Modulus on each element, giving us [0, 1, 2]
        -    #Subtract each element, giving us [12, 12, 12]

3
คำตอบที่ดี! คุณสามารถบันทึกไบต์โดยใช้5M(คลิปบอร์ดอัตโนมัติฟังก์ชั่นของปัจจัยการผลิต) 2:4แทนสอง
David

@ David ขอบคุณสำหรับคำแนะนำ!
DJMcMayhem

12

MATL, 8 ไบต์

Qt_2:4\+

ใช้อัลกอริทึมของ Denis 'Jelly ฉันประหลาดใจว่าความยาวเท่ากัน!

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

Q    % takes implicit input and increments by one
t_   % duplicate, and negate top of stack (so it's -(n+1))
2:4  % push vector [2 3 4]
\    % mod(-(n+1),[2 3 4])
+    % add result to input+1
     % implicit display

มันแย่มาก ฉันภูมิใจในโซลูชัน 10 ไบต์ของฉัน แต่ฉันไม่สามารถเอาชนะสิ่งนี้ได้ นอกจากนี้เรื่องสนุก: นี่คือการลงคะแนนเสียงครั้งที่ 300 ของฉัน = D
DJMcMayhem

อ่า แต่นี่เป็นเพียงการใช้อัลกอริทึมของ Agawa / Dennis มันไม่ใช่ความคิดของฉันเอง
David

1
บางครั้งฉันยังจ้องมองที่ตัวละครยูนิโค้ด mandarinoid เหล่านั้นในขณะที่เกาหัวของฉันแล้วฉันพูดว่า "เพราะทุกสิ่งที่อ่านได้คือรหัสฟอร์กรันนิก"? ฮ่า ๆ สิ่งที่ดีมี upvote ของฉัน + ฉันจะเข้าร่วมรถไฟ matl sooon
Abr001am

@ Agawa001 คุณควรจะ! เมื่อทราบว่าวิธีการของคุณรอบ ๆ Matlab ค่อนข้างดีคุณควรพบว่ามันค่อนข้างตรงไปตรงมา มีห้องสนทนา MATLเช่นกันหากคุณต้องการความช่วยเหลือ!
David

@ David ที่แพนเค้กตามธรรมชาติของ matl ทำให้มันน่ากลัวยิ่งกว่าอย่างรู้เท่าทันว่า matlab ดิบนั้นเป็นภาษาที่เป็นมิตรกับกอล์ฟเกี่ยวกับความสามารถในการโต้ตอบระดับสูงดังนั้นลองจินตนาการ ....
Abr001am


6

05AB1E , 8 ไบต์

รหัส:

>D(3L>%+

ลองออนไลน์! .


อ่าไม่ได้สังเกตว่ามีคำตอบ 05AB1E อยู่แล้วซึ่งค่อนข้างคล้ายกับที่ฉันมี ฉันได้ลบมันแล้วและจะแนะนำให้เป็นกอล์ฟ -1 ที่นี่แทน: ±D2xŸ%α( 2xŸเป็นเพียงทางเลือกสำหรับคุณ3L>และอีกสองทางเลือกเท่ากับไบต์อาจเป็นƵ…Sหรือ4L¦)
Kevin Cruijssen




4

Mathematica ขนาด 21 ไบต์

Ceiling[#+1,{2,3,4}]&

นี่คือฟังก์ชั่นที่ไม่มีชื่อซึ่งใช้จำนวนเต็มเดียวเป็นอินพุตและส่งกลับรายการของทวีคูณ

Ceilingฟังก์ชั่นใช้เวลาพารามิเตอร์ที่สองตัวเลือกที่จะบอกว่ามันจะรอบขึ้นไปหลายต่อไปของตัวเลขที่กำหนด โชคดีที่มันยังมีเธรดสำหรับอาร์กิวเมนต์ที่สองโดยอัตโนมัติเพื่อให้เราสามารถให้รายการของค่าและในทางกลับกันเราจะได้ทวีคูณเป็นทวีคูณสำหรับทุกค่า


4

อ็อกเทฟ 20 ไบต์

@(n)n-mod(n,d=2:4)+d

ตัวอย่าง:

octave:60> f(123)
ans =

   124   126   124

octave:61> f(1081177)
ans =

   1081178   1081179   1081180

octave:62> f(420)
ans =

   422   423   424

น่าสังเกตว่าเราสามารถทำได้ถึง 9 โดยไม่ต้องเพิ่มไบต์พิเศษ:

@(n)n-mod(n,d=2:9)+d

เอาท์พุท (2520 เป็นจำนวนเต็มบวกที่เล็กที่สุดหารด้วยตัวเลขหลักเดียวทั้งหมด):

octave:83> f(2520)
ans =

   2522   2523   2524   2525   2526   2527   2528   2529


4

เขาวงกต , 19 ไบต์

:?
:
#/)
\ #
!"*@
"

ลองออนไลน์!

สิ่งนี้จะแสดงผลลัพธ์ตามลำดับที่C, B, Aคั่นด้วย linefeeds

คำอธิบาย

ตามปกติไพรเมอร์เขาวงกตสั้น:

  • เขาวงกตมีจำนวนเต็มสองจำนวนที่แน่นอนโดยพลการหลักและaux (iliary) ซึ่งเต็มไปด้วยศูนย์ (โดยปริยาย) จำนวนอนันต์ เราจะใช้หลักเท่านั้นสำหรับคำตอบนี้เท่านั้น
  • ซอร์สโค้ดมีลักษณะคล้ายเขาวงกตที่ซึ่งตัวชี้คำแนะนำ (IP) ตามทางเดินเมื่อมันสามารถ (แม้รอบมุม) รหัสเริ่มต้นที่อักขระตัวแรกที่ถูกต้องในลำดับการอ่านคือที่มุมบนซ้ายในกรณีนี้ เมื่อ IP มาถึงจุดเชื่อมต่อรูปแบบใด ๆ (เช่นเซลล์ที่อยู่ติดกันหลายแห่งนอกเหนือจากที่มาจาก) มันจะเลือกทิศทางตามด้านบนของสแต็กหลัก กฎพื้นฐานคือเลี้ยวซ้ายเมื่อลบเดินหน้าต่อไปเมื่อศูนย์เลี้ยวขวาเมื่อบวก และเมื่อหนึ่งในสิ่งเหล่านี้เป็นไปไม่ได้เพราะมีกำแพงแล้ว IP จะไปในทิศทางตรงกันข้าม IP ยังหันไปรอบ ๆ เมื่อกดปุ่ม Dead Dead

แม้จะไม่มีสองตัวเลือก ( ") ที่ทำให้รูปแบบดูเหมือนจะสิ้นเปลืองฉันมีความสุขมากกับวิธีนี้เนื่องจากการควบคุมการไหลของมันค่อนข้างบอบบาง

IP เริ่มต้นที่มุมบนซ้ายของ:ทางขวา มันจะไปถึงจุดสิ้นสุดทันที?และหันกลับมาเพื่อให้โปรแกรมเริ่มต้นด้วยโค้ดเชิงเส้นนี้:

:   Duplicate top of main stack. This will duplicate one of the implicit zeros
    at the bottom. While this may seem like a no-op it actually increases
    the stack depth to 1, because the duplicated zero is *explicit*.
?   Read n and push it onto main.
:   Duplicate.
:   Duplicate.

นั่นหมายความว่าเรามีตอนนี้สามสำเนาของnในกองหลัก 4แต่ความลึกของมันคือ สะดวกเพราะมันหมายความว่าเราสามารถสแต็คลึกเพื่อดึงตัวคูณปัจจุบันในขณะที่ทำงานผ่านสำเนาของอินพุต

IP จะเข้าสู่วงวน 3x3 (ตามเข็มนาฬิกา) โปรดทราบว่า#ซึ่งผลักความลึกของสแต็กจะผลักดันค่าบวกเสมอซึ่งเรารู้ว่า IP จะหันไปทางทิศตะวันออก ณ จุดนี้เสมอ

ร่างกายห่วงคือ:

#   Push the stack depth, i.e. the current multiplier k.
/   Compute n / k (rounding down).
)   Increment.
#   Push the stack depth again (this is still k).
*   Multiply. So we've now computed (n/k+1)*k, which is the number
    we're looking for. Note that this number is always positive so
    we're guaranteed that the IP turns west to continue the loop.
"   No-op.
!   Print result. If we've still got copies of n left, the top of the 
    stack is positive, so the IP turns north and does another round.
    Otherwise, see below...
\   Print a linefeed.
    Then we enter the next loop iteration.

หลังจากวนซ้ำ (สูงสุด!) สามครั้งสำเนาทั้งหมดnจะถูกใช้หมดและไม่มีการเปิดเผยศูนย์ที่อยู่ด้านล่าง เนื่องจาก"ที่ด้านล่าง (ซึ่งเป็นอย่างอื่นดูเหมือนว่าไร้ประโยชน์สวย) ตำแหน่งนี้เป็นทางแยก นั่นหมายความว่าด้วยศูนย์ที่ด้านบนของสแต็ค IP พยายามที่จะไปข้างหน้า (ตะวันตก) แต่เนื่องจากมีกำแพงมันจึงหมุนได้ 180 องศาแล้วเคลื่อนที่กลับไปทางตะวันออกราวกับว่ามันถูกจุดตายแล้ว

ด้วยเหตุนี้บิตต่อไปนี้จึงถูกเรียกใช้งาน:

"   No-op.
*   Multiply two zeros on top of the stack, i.e. also a no-op.
    The top of the stack is now still zero, so the IP keeps moving east.
@   Terminate the program.



3

JavaScript (ES6), 26 ไบต์

การตอบคำตอบ Ruby ของ @ KevinLau ที่น่าสนใจหรือคำตอบ Python ของ @ xnor นั้นมีความยาวเท่ากัน:

n=>[2,3,4].map(d=>n+d-n%d)
n=>[n+2&-2,n+3-n%3,n+4&-4]

ฉันมีการตั้งค่าเล็กน้อยสำหรับพอร์ตของคำตอบ Ruby เนื่องจากมันทำงานได้ถึง 2 53 53ในขณะที่พอร์ตของคำตอบ Python นั้นใช้งานได้ถึง 2 31 -5 เท่านั้น


)-> ]อย่างที่ฉันคิด
Qwertiy

@Qwertiy อ๊ะขอโทษสำหรับการพิมพ์ผิด
Neil

3

C, 50 46 ไบต์

i;f(int*a,int n){for(i=1;++i<5;*a++=n+i-n%i);}

ขอบคุณ Neil และ nwellnhof สำหรับการบันทึก 4 ไบต์!

ยาวอย่างน่าผิดหวัง ฉันรู้สึกเหมือนมีการแฮ็กบิตสับเปลี่ยนที่นี่ที่ฉันไม่รู้ แต่ก็ยังหาไม่เจอ ส่งกลับตัวชี้ไปยังอาร์เรย์ที่ถือองค์ประกอบสามอย่าง โปรแกรมเต็มรูปแบบ:

i;f(int*a,int n){for(i=1;++i<5;*a++=n+i-n%i);}

int main()
{
    int array[3];
    int n=10;
    f(array, n);
    printf("A:%d\tB:%d\tC:%d\n",array[0],array[1],array[2]);
    return 0;
}

ฉันดูที่ twinkling ของ @ xnor แต่คุณต้องคลี่วงสำหรับสิ่งที่ทำให้คุณต้องเสียค่าใช้จ่ายโดยรวมเป็นไบต์
Neil

ไม่ได้n + i - n % i++ส่งผลให้พฤติกรรมที่ไม่ได้กำหนด?
nwellnhof

นอกจากนี้ยังs/a[i-2]/*a++/บันทึกสองไบต์
nwellnhof

@nwellnhof Bah ฉันคิดว่าเมื่อฉันยกเลิกการควบคุมวง แต่มันไม่ได้เกิดขึ้นกับฉันที่เขาสามารถใช้งานได้
Neil

2
@Neil แต่พฤติกรรมที่ไม่ได้กำหนดสามารถแก้ไขได้โดยไม่ทำให้โค้ดใหญ่ขึ้น นี่คือรุ่นที่สั้นกว่าโดยใช้การประกาศฟังก์ชัน K&R:f(a,n,i)int*a;{for(i=1;++i<5;)*a++=n+i-n%i;}
nwellnhof

3

Reng, 40 ไบต์

i1+#i2341ø>(1+)31j
i(2[¤,  q!^$]æl0eq!~

1: init

i1+#i2341ø

i1+#iกำหนดอินพุตเป็น1 + input; นี่เป็นเพราะเราต้องทำงานกับจำนวนที่มากกว่าอินพุต 234เริ่มต้นเทปด้วยค่าการวนซ้ำของเราและข้ามไปที่จุดเริ่มต้นของบรรทัดถัดไป

2a: วนซ้ำ

i(2[¤,  q!^$]æl0eq!~

i(วางอินพุตที่ STOS และ2[สร้างสแต็กใหม่ที่มีองค์ประกอบ 2 อันดับแรก ¤ทำซ้ำสแต็กและ,ทำโมดูลัส หากมีเศษเหลือให้q!^ออกจากลูปเพื่อไปที่ (b) มิฉะนั้นเราก็ไม่สามารถพิมพ์ได้ $ลบสิ่งที่พิเศษ]ปิดกองและæพิมพ์อย่างสวยงามl0wq!~ยุติ iff สแต็กมีสมาชิกศูนย์

2b: ห่วงอื่น ๆ

          >(1+)31j
        q!^

(1+) เพิ่ม 1 ใน STOS และ 31jข้ามไปยังส่วนของลูปที่ไม่ได้นำสิ่งต่าง ๆ จากสแต็ก และกำไร


ช่องว่างพิเศษนั้นรบกวนฉันจริงๆ รับ GIF

REENNNNNGGG


3

Retina, 62 43 26 ไบต์

17 bytes ขอบคุณ@Martin BüttnerBüttner

^
1111:
! M & `(11 +): (\ 1 *)
:

(สังเกตบรรทัดใหม่ที่ตามมา)

ลองออนไลน์!

อินพุตเป็น unary ใน1, เอาต์พุตเป็น unary ใน1คั่นด้วยบรรทัดใหม่

รุ่น 43 ไบต์ก่อนหน้า:

.+
11:$&;111:$&;1111:$&
\b(1+):(\1*)1*
$1$2

ลองออนไลน์!

อินพุตเป็น unary เอาต์พุตใน unary คั่นด้วยเซมิโคลอน ( ;)

รุ่น 62 ไบต์ก่อนหน้า:

.+
$&11;$&111;$&1111
((11)+)1*;((111)+)1*;((1111)+)1*
$1;$3;$5

ลองออนไลน์!

อินพุตเป็น unary เอาต์พุตใน unary คั่นด้วยเซมิโคลอน ( ;)


26 ถ้าอนุญาตให้แสดงผลลัพธ์ในลำดับตรงกันข้าม: retina.tryitonline.net/ ...... มิฉะนั้น 33 ฉันคิดว่าต้องมีวิธีที่สั้นกว่าเพื่อหลีกเลี่ยงการเรียงลำดับย้อนกลับ: retina.tryitonline.net/ …
Martin Ender

เพียงพอที่จะถือว่าเป็นคำตอบที่แยกจากกันหรือไม่
Leun Nun

ฉันไม่รู้มันยังคงเป็นแนวคิดเดียวกันฉันเพิ่งสร้างรายการด้วยตนเองโดยใช้การจับคู่ที่ทับซ้อนกัน
Martin Ender

Conor ยืนยันว่าโซลูชัน 26- ไบต์นั้นถูกต้อง
Martin Ender

3

Octave, 27 22 20 bytes

MATLAB และอ็อกเทฟ:

f=2:4;@(x)f.*ceil((x+1)./f)

ดีกว่า (การแก้ปัญหาเทียบเท่ากัน แต่อาจจะดีกว่าอีกอันเมื่อเล่นกอล์ฟเพิ่มเติม), MATLAB และ Octave:

@(x)x-rem(x,2:4)+(2:4)
f=2:4;@(x)x+f-rem(x,f)

เฉพาะในระดับแปดเสียง:

@(x)x-rem(x,h=2:4)+h

ลองที่นี่


คำตอบสุดท้ายของฉันคือที่นี่ :( codegolf.stackexchange.com/a/80028/52795
bers



2

Mathematica 28 ไบต์

f@n_:=n-n~Mod~#+#&/@{2,3,4}

f[1]
f[4]
f[43]
f[123]
f[420]
f[31415]
f[1081177]

{2, 3, 4}

{6, 6, 8}

{44, 45, 44}

{124, 126, 124}

{422, 423, 424}

{31416, 31416, 31416}

{1081178, 1081179, 1081180}


กรณีทั่วไปสร้างคำตอบทั่วไป:

f[r]

{2 + r - Mod [r, 2], 3 + r - Mod [r, 3], 4 + r - Mod [r, 4]}


2

R, 30 26 ไบต์

(ลดลง 4 ไบต์ด้วย @Neil)

N=scan();cat(N+2:4-N%%2:4)

(คล้ายกับส่วนที่เหลือของคำตอบที่ฉันเดา) เพิ่ม 2: 4 ในอินพุตและลดส่วนที่เหลือหลังจากรันโมดูโลบนหมายเลขเดียวกัน


1
เมื่อฉันไม่รู้ภาษามีเหตุผลที่คุณไม่ใช้N+2:4-N%%2:4หรือไม่
Neil

@Neil เพราะฉันไม่ได้คิดว่าฉันเดา ขอบคุณ
David Arenburg

2

UGL , 51 31 25 24 ไบต์

icu$l_u^^/%_u^*ocO$dddd:

ลองออนไลน์!

รุ่น 25 ไบต์ก่อนหน้า:

iRcu$l_u$r^/%_u*ocO$dddd:

ลองออนไลน์!

รุ่น 31 ไบต์ก่อนหน้า:

iRcuuulu$cuuuuuu%-r^/%_u*oddcO:

ลองออนไลน์!

รุ่น 51 ไบต์ก่อนหน้า:

i$$cuuu/%_ucuuu*@cuuuu/%_ucuuuu*@cuu/%_ucuu*ocOocOo

ลองออนไลน์!




1

จริงแล้ว 22 ไบต์

╗52x"╝1`;╛@%Y@╜<*`╓"£M

ลองออนไลน์!

ความจริง: 3 ข้อบกพร่องในล่ามของจริงแล้วพบและแก้ไขในขณะที่เขียนโปรแกรมนี้

ไม่ใช่เรื่องสนุกจริง: ข้อบกพร่อง 3 ข้อเหล่านั้นป้องกันไม่ให้โซลูชันนี้สั้นลงมาก

คำอธิบาย:

╗52x"╝1`;╛@%Y@╜<*`╓"£M
╗                       push input to reg0
 52x                    push range(2,5) ([2,3,4])
    "╝1`;╛@%Y@╜<*`╓"£M  map (for n in [2,3,4]):
     ╝                    push n to reg1
      1`;╛@%Y@╜<*`╓       find the smallest integer k where:
        ;╛@%Y               k is divisible by n and...
             @╜<*           is greater than the input

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.