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

ตัวอย่าง: หารของN = 241, 2, 3, 4, 6, 8, 12, 24มี จำนวนเต็มบวกที่เล็กที่สุดซึ่งไม่ได้อยู่ในรายการนั้นคือ5ดังนั้นนั่นคือผลลัพธ์ที่โซลูชันของคุณควรค้นหา

นี่คือลำดับ OEIS A007978

กฎระเบียบ

คุณสามารถเขียนโปรแกรมหรือฟังก์ชั่นและใช้วิธีการมาตรฐานของเราในการรับอินพุตและให้เอาต์พุต

คุณอาจใช้ภาษาการเขียนโปรแกรมใด ๆแต่โปรดทราบว่าช่องโหว่เหล่านี้เป็นสิ่งต้องห้ามตามค่าเริ่มต้น

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดที่ถูกต้อง - วัดเป็นไบต์ - ชนะ

กรณีทดสอบ

100 คำแรกคือ:

2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 
3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 
2, 3, 2, 4, 2, 3, 2, 3, 2, 7, 2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 2, 
3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 2, 3

ตรวจสอบให้แน่ใจว่าคำตอบของคุณใช้ได้กับอินพุต1และ2ซึ่งในกรณีนี้ผลลัพธ์จะใหญ่กว่าอินพุต

และสำหรับกรณีทดสอบที่ใหญ่กว่า:

N          f(N)
1234567    2
12252240   19
232792560  23

Mathematica, 19 ไบต์ (การเข้ารหัส UTF-8)

1//.x_/;x∣#:>x+1&

ฟังก์ชั่นที่ไม่มีชื่อการโต้แย้งอาร์กิวเมนต์จำนวนเต็มและส่งกลับจำนวนเต็มบวก แถบแนวตั้งประมาณครึ่งทางคือจริงๆแล้วคืออักขระสามไบต์ U + 2223 ซึ่งหมายถึงความสัมพันธ์ระหว่างการหารใน Mathematica คำอธิบาย:

1                   Starting with 1,
 //.                apply the following rule until it stops mattering:
    x_                if you see a number x
      /;x∣#           such that x divides the function argument,
           :>x+1      replace it with x+1.
                &   Cool, that's a function.

แก้ไขเพื่อเพิ่ม: ngenisis ชี้ให้เห็นว่า//.โดยค่าเริ่มต้นจะทำซ้ำสูงสุด 65536 ครั้ง ดังนั้นการติดตั้งนี้จึงใช้งานได้กับหมายเลขอินพุตทั้งหมดที่น้อยกว่าตัวคูณร่วมที่น้อยที่สุดของจำนวนเต็มตั้งแต่ 1 ถึง 65538 (โดยเฉพาะอย่างยิ่งกับตัวเลขทั้งหมดที่มีตัวเลขมากที่สุด 28436 หลัก) แต่ในทางเทคนิคแล้วไม่ใช่สำหรับตัวเลขทั้งหมด หนึ่งสามารถแทนที่x//.yด้วยReplaceRepeated[x,y,MaxIterations->∞]เพื่อแก้ไขข้อบกพร่องนี้ แต่เห็นได้ชัดว่ามีราคา 34 ไบต์เพิ่มเติม

Pyth, 3 ไบต์

f%Q

โดยทั่วไปfวนรอบโค้ดจนกว่า%QT( Q % Tโดยที่Tตัวแปรการวนซ้ำ) เป็นจริง

ลองออนไลน์ได้ที่นี่

JavaScript (ES6), 25 23 ไบต์

f=(n,k)=>n%k?k:f(n,-~k)

หมายเหตุ:สิ่งหนึ่งที่น่าสนใจที่นี่คือkพารามิเตอร์เริ่มต้นจาก nihiloในการทำซ้ำครั้งแรก งานนี้เพราะn % undefinedเป็นNaN(falsy เป็นไปตามคาด) และเท่ากับ-~undefined 1เกี่ยวกับการทำซ้ำต่อไปเป็นหลักเทียบเท่ากับ-~kk+1

ทดสอบ

f=(n,k)=>n%k?k:f(n,-~k)

// first 100 terms
for(i = 1, list = []; i <= 100; i++) {
  list.push(f(i));
}
console.log(list.join(' '));

// larger test cases
console.log(f(1234567));
console.log(f(12252240));
console.log(f(232792560));

Python 43 36 35 ไบต์

f=lambda n,d=2:d*(n%d>0)or f(n,d+1)

Hexagonyขนาด 12 ไบต์

\\)?}'@{!%.}

Embiggened:

   \ \ )
  ? } ' @
 { ! % . }
  . . . .
   . . .

ลองออนไลน์!

R, 28 ไบต์

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

i=scan()
while(!i%%T)T=T+1
T

หากคุณต้องการบางสิ่งบางอย่างแฟนซีมากกว่ามี29 ไบต์ต่อไปนี้:

i=scan()
match(0,!i%%1:(i+1))

อธิบาย:

i=scan(): อ่านiจาก stdin

1:(i+1): สร้างจำนวนเต็มทั้งหมดจาก1ถึงi+1(การ+1บัญชีสำหรับเคส1และ2)

i%%1:(i+1) : Modulo อินพุตโดยทุกหมายเลขในรายการของเรา

!i%%1:(i+1): ลบรายการผลลัพธ์ นี้โดยปริยายแปลงให้เป็นชนิดตรรกะดังกล่าวที่0เป็นและไม่เป็นศูนย์คือFALSE TRUEหลังจากลบล้างTRUEคุณค่ากลายเป็นFALSEและในทางกลับกัน FALSEตอนนี้ค่าภัณฑ์เดิมทั้งหมดจะถูกกำหนดเป็น

match(0,!i%%1:(i+1)): คืนดัชนีอินสแตนซ์แรกของ0ในรายการของเรา 0เป็นFALSEเช่นนี้ผลตอบแทนดัชนีของครั้งแรกFALSEในรายการซึ่งเป็นค่าไม่ใช่ศูนย์ครั้งแรกจากการดำเนินงานแบบโมดูโล ตั้งแต่รายการเริ่มต้นของเราเริ่มต้น1ดัชนีจะเท่ากับมูลค่าของตัวหารที่เล็กที่สุด

Haskell, 26 ไบต์

f n=until((>0).mod n)(+1)1

ทุกคนลืมเกี่ยวกับuntil!

Brachylogขนาด 10 ไบต์

~{=#>:A'*}

ลองออนไลน์!

สิ่งนี้ออกมาคล้ายกันมากกับ (แต่สั้นกว่า) โซลูชันดั้งเดิมของ Fatalize Fatalize ได้เปลี่ยนไปใช้อัลกอริทึมที่แตกต่างกันซึ่งเชื่อมโยงกับวิธีนี้ด้วยวิธีที่แตกต่างกันดังนั้นฉันจะต้องอธิบายด้วยตัวเอง:

~{=#>:A'*}
~{       }    inverse of the following function:
  =           try possible values for the input, if it's unbound
   #>         the input is a positive integer
     :A'*     there is no A for which the input times A is the output

เมื่อเราสลับฟังก์ชั่นโดยการสลับ "อินพุท" และ "เอาท์พุท" เราจะได้อัลกอริธึมที่สมเหตุสมผล (เพียงแสดงในลักษณะที่น่าอึดอัดใจ): "ลองจำนวนเต็มบวกที่เป็นไปได้ตามลำดับธรรมชาติ (เช่น 1 ขึ้นไป) อันที่ไม่สามารถคูณด้วยอะไรก็ได้เพื่อสร้างอินพุต " Brachylog ไม่ได้ทำการคำนวณแบบ floating-point เว้นแต่จะทราบอินพุตทั้งหมดดังนั้นมันจะพิจารณาเฉพาะจำนวนเต็ม A เท่านั้น

Brachylogขนาด11 10 ไบต์

,.=:?r'%0'

ลองออนไลน์!

คำอธิบาย

,.=           Assign an integer to the output
 . :?r'%0     Input mod Output ≠ 0
        0'    Output ≠ 0

COW, 174 ไบต์

oomMOOMMMmoOmoOmoOMMMmOomOoMoOMMMmoOmoOmoOMMMmOoMOOmoO
MOomoOMoOmOoMOOmoOmoomoOMOOmOoMoOmoOMOomoomOomOoMOOmOo
moomoOMOomoomoOmoOMOOmOomOomOomOoOOMOOOMOomOOmoomOomOo
mOomOomOomoo

ลองออนไลน์!

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

การวิเคราะห์รหัส

oom                          ;Read input into [0].
MOO                          ;Loop while [0].  We never change [0], so the program only terminates forcibly after a print.
  MMMmoOmoOmoOMMMmOomOo      ; Copy [0] to [3] and navigate to [1].
  MoOMMMmoOmoOmoOMMM         ; Increment [1], and copy it to [4]
  mOo                        ; Navigate back to [3].
  MOO                        ; Modulus algorithm.  Direct port of brainfuck algorithm.
    moOMOomoOMoOmOo
    MOO
      moO
    moo
    moO
    MOO
      mOoMoOmoOMOo
    moo
    mOomOo
    MOO
      mOo
    moo
    moOMOo
  moo                        ; End modulus algorithm.
  moOmoO                     ; Navigate to [5].  This contains our modulus.
  MOO                        ; Only perform these operations if [5] is non-zero -- i.e. [0] % [1] != 0
    mOomOomOomOoOOMOOOMOomOO ;  Navigate to [1], print its contents, then error out.
  moo                        ; End condition
  mOomOomOomOomOo            ; Since we're still running, [0] % [1] == 0, so navigate back to [0] and try again.
moo                          ;End main loop.

คำอธิบาย

รหัสจะอ่านจำนวนเต็มเป็น [0] ก่อน การวนซ้ำแต่ละครั้งของลูปหลัก (บรรทัดที่ 2 ถึง 26) เพิ่มขึ้น [1] จากนั้นคัดลอกทุกสิ่งที่จำเป็นไปยังอัลกอริธึมโมดูลัสซึ่งแยกผลลัพธ์ออกเป็น [5] หาก [5] มีค่าใด ๆ ดังนั้น [1] คือหมายเลขที่เราต้องการพิมพ์ เราพิมพ์แล้วบังคับให้ออกจากโปรแกรม

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

(0) moo -- Equivalent to ]
(1) mOo -- Equivalent to <
(2) moO -- Equivalent to >
(3) mOO -- No equivalent.  Evaluate current tape value as instruction from this list.
(4) Moo -- If tape is 0, equivalent to ,; if tape is non-zero, equivalent to .
(5) MOo -- Equivalent to -
(6) MoO -- Equivalent to +
(7) MOO -- Equivalent to [
(8) OOO -- No equivalent.  Set tape (positive or negative) to 0
(9) MMM -- No equivalent.  If register is empty, copy tape to register.  If register is non-empty, paste register to tape and clear register.
(10) OOM -- No equivalent.  Print an integer from tape to STDOUT
(11) oom -- No equivalent.  Read an integer from STDIN and store it on tape

จุดที่แท้จริงของการสนใจที่นี่เป็นคำแนะนำที่ mOO3 ล่ามอ่านค่าเทปปัจจุบันและดำเนินการคำสั่งตามค่าเทปนั้น หากค่าน้อยกว่า 0 มากกว่า 11 หรือเท่ากับ 3 ล่ามจะยุติการทำงานของโปรแกรม เราสามารถใช้สิ่งนี้เป็นแรงออกอย่างรวดเร็วและสกปรกออกจากลูปหลัก (และโปรแกรมทั้งหมด) เมื่อเราพบผู้ไม่หารของเรา สิ่งที่เราต้องทำคือพิมพ์หมายเลขของเราล้าง [1] (ด้วยOOO) ลดลงเหลือ -1 ด้วยMOoแล้วดำเนินการคำสั่ง -1 ผ่านmOOซึ่งจบโปรแกรม

เทปสำหรับโปรแกรมนี้ทำหน้าที่ดังต่อไปนี้:

[0]  -- Read-in integer from STDIN.
[1]  -- Current divisor to test
[2]  -- Placeholder for modulus algorithm
[3]  -- Temporary copy of [0] for use for modulus algorithm
[4]  -- Temporary copy of [1] for use for modulus algorithm
[5]  -- Placeholder for modulus algorithm.  Location of remainder at end of loop.
[6]  -- Placeholder for modulus algorithm
[7]  -- Placeholder for modulus algorithm

อัลกอริธึมโมดูลัสจะล้าง [2], [3], [6] และ [7] ในตอนท้ายของการดำเนินการ [4] เนื้อหาของถูกเขียนทับด้วย register วางบนบรรทัด 4 และ [5] เป็นศูนย์เมื่อ [0] หารด้วย [1] ดังนั้นเราไม่ต้องเคลียร์มัน หาก [5] ไม่ใช่ศูนย์เราจะบังคับให้ออกจากบรรทัดที่ 23 ดังนั้นเราไม่ต้องกังวลเกี่ยวกับมัน

05AB1E , 7 ไบต์

Xµ¹NÖ_½

ลองออนไลน์!

คำอธิบาย

Xµ       # run until counter is 1
  ¹      # push input
   N     # push iteration counter
    Ö_   # push input % iteration counter != 0
      ½  # if true, increase counter
         # output last iteration

เยลลี่ 5 ไบต์

1%@#Ḣ

ลองออนไลน์!

คำอธิบาย:

1%@#Ḣ
1  #      Find the first … numbers, counting up from 1, such that
 %@       dividing those numbers into … gives a truthy remainder
    Ḣ     then return the first

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

C, 32 35 ไบต์

i;f(x){for(i=1;x%++i<1;);return i;}

แก้ไข: เพิ่มi=1ในลูป

การใช้

main(c,v)char**v;{printf("%d",f(atoi(*++v)));}

เวอร์ชันเต็มของโปรแกรม 64 ไบต์:

main(c,v)char**v;{*++v;for(c=1;atoi(*v)%++c<1;);printf("%d",c);}

C #, 39 37 ไบต์

n=>{int i=0;while(n%++i<1);return i;}

บันทึกสองไบต์ด้วย Martin

Perl, 19 ไบต์

18 ไบต์ของรหัส + -pธง

$_=$_%++$.?$.:redo

วิธีเรียกใช้:

perl -pE '$_=$_%++$.?$.:redo' <<< 12252240

คำอธิบายโดยละเอียดไม่มาก :
- $.เป็นตัวแปรพิเศษที่มีค่าเริ่มต้นคือหมายเลขบรรทัดปัจจุบันของการเข้าถึงไฟล์ครั้งล่าสุด (stdin ที่นี่) ดังนั้นหลังจากอ่านบรรทัดแรกของอินพุตมันถูกตั้งค่าเป็น 1
- $_เก็บอินพุตและพิมพ์โดยปริยาย ในตอนท้าย (ขอบคุณ-pธง)
- redo(ในบริบทนั้น) พิจารณาว่าโปรแกรมอยู่ในลูปและทำซ้ำการทำซ้ำปัจจุบัน (เฉพาะ$.จะแตกต่างกันเนื่องจากมันเพิ่มขึ้น)
- ดังนั้นหากเราพบจำนวนน้อยที่สุด (เก็บไว้ใน$.) ที่ไม่ได้แบ่งออก$_เราก็ตั้งค่า$_เป็นมิฉะนั้นเราจะลองหมายเลขถัดไป (ขอบคุณredo)

ระดับแปดเสียง / MATLAB, 26 24 ไบต์

@(n)find(mod(n,1:n+1),1)

find(...,1)ส่งคืนดัชนี ( 1- ตาม) ขององค์ประกอบที่ไม่ใช่ศูนย์แรกของเวกเตอร์ในอาร์กิวเมนต์แรก อาร์กิวเมนต์แรก[n mod 1, n mod 2, n mod 3, n mod 4,...,n mod (n+1)]นั่นหมายความว่าเราจะต้องเพิ่มดัชนีตั้งแต่เราเริ่มต้นการทดสอบที่+1 1ขอบคุณ @Giuseppe สำหรับ -2 ไบต์

ลองออนไลน์!

เยลลี่ 6 ไบต์

%R;‘TḢ

ลองออนไลน์!

คำอธิบาย:

                                               Assume 24 is our N
 R      Generate all numbers from 1 to N         [1, 2, 3, 4 .., 24]
  ;‘    Attach N+1 to that list (for cases 1,2)  [1, 2, 3, 4 .., 25]
%       And modulo-divide our input by it
        Yields a list with the remainder         [0, 0, 0, 0, 4 ...]
    T   Return all thruthy indexes               [5, 7, ...]
     Ḣ  Takes the first element of that list -->  5

Perl 6 , 17 ไบต์

{first $_%*,1..*}

ลองมัน

ขยาย:

{  # bare block lambda with implicit parameter ｢$_｣

  # return the first value
  first

  # where the block's argument ｢$_｣ modulus the current value ｢*｣
  # doesn't return 0 ( WhateverCode lambda )
  $_ % *,
  # ( ｢$_ !%% *｣ would be the right way to write it )

  # from 1 to Whatever
  1 .. *
}

05AB1E , 6 ไบต์

ÌL¹ÑK¬

ลองออนไลน์!

นอกจากนี้ยังมีคาถา "ลิงค์!" ...

ÌL     # Push [1..n+2]
  ¹Ñ   # Push divisors of n.
    K¬ # Push a without characters of b, and take first item.

เยลลี่ 5 ไบต์

‘ḍ€i0

ลองออนไลน์!

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

‘ḍ€i0  Main link. Argument: n

‘      Increment; yield n+1.
 ḍ€    Divisible each; test 1, ..., n+1 for divisibility by n.
   i0  Find the first index of 0.

Python 2.7.9, 32 ไบต์

f=lambda n,d=1:n%d>0or-~f(n,d+1)

ทดสอบไอดีโอ

จะนับจำนวนผู้ไม่dหวังดีอีกต่อไป dมันสั้นไปซ้ำส่วนเกินผลกว่าการส่งออก อ็อฟเซ็ตของ1ทำได้โดยบูลีนTrueซึ่งเท่ากับ1แต่เนื่องจากd==1เป็นตัวหารเสมอเอาต์พุตจะถูกแปลงเป็นตัวเลขเสมอ

Python 2.7.9 0orจะใช้ในการอนุญาตให้มีการอนุญาตให้ รุ่นที่เริ่มต้น 2.7.10 จะพยายามแยกวิเคราะห์0orเป็นจุดเริ่มต้นของหมายเลขฐานแปดและได้รับข้อผิดพลาดทางไวยากรณ์ ดูนี้บน Ideone

ที่จริงแล้ว 7 ไบต์

;÷@uR-m

ลองออนไลน์! (หมายเหตุ: นี่เป็นวิธีแก้ปัญหาที่ช้ามากและจะใช้เวลานานสำหรับกรณีทดสอบขนาดใหญ่)

คำอธิบาย:

;÷@uR-m
;÷       duplicate N, divisors
  @uR    range(1, N+2)
     -   set difference (values in [1, N+1] that are not divisors of N)
      m  minimum

Haskell , 29 ไบต์

f n=[k|k<-[2..],mod n k>0]!!0

การแสดงออกเพียงแค่สร้างรายการที่ไม่มีที่สิ้นสุด[k|k<-[2..]] [2,3,4,5,...]ด้วยเงื่อนไขที่mod n k>0เราอนุญาตให้ผู้ที่อยู่ในรายชื่อที่ไม่ได้แบ่งk nการต่อท้าย!!0จะส่งคืนรายการแรก (รายการที่ดัชนี0) รายการนั้น

ลองออนไลน์!

Dyalog APL ขนาด 8 ไบต์

1⍳⍨0≠⍳|⊢

1⍳⍨ ตำแหน่งของ True แรกใน

0≠ ค่าที่ไม่เป็นศูนย์ของ

⍳|ส่วนที่เหลืออยู่ของ 1 ... Nเมื่อหารด้วย

⊢ ยังไม่มีข้อความ

ลองใช้ออนไลน์!

หมายเหตุ: ใช้งานได้กับ 1 และ 2 เพราะ1⍳⍨ส่งคืน 1 + ความยาวของอาร์กิวเมนต์หากไม่พบ

จูเลีย 28 ไบต์

N->findfirst(x->N%x>0,1:N+2)

หมายเหตุ: เนื่องจาก1:N+2ไม่ได้จัดสรรหน่วยความจำจึงไม่มีปัญหาเรื่องหน่วยความจำสำหรับNs
- @flawr ขนาดใหญ่N+2ประหยัดสำหรับฉันบางไบต์
- คำแนะนำของ @Martin บันทึก 1 ไบต์

QBICขนาด 14 ไบต์

:[a+1|~a%b|_Xb

คำอธิบาย:

:      Read the first cmd line param as a number, called 'a'
[a+1|  FOR (b=1 ; b <= a+1; b++) <-- a+1 for cases a = 1 or 2
~a%b   IF A modulo B ( == 0, implicit)
|_Xb   THEN exit the program, printing b
       [IF and FOR implicitly closed by QBIC]

PHP, 30 ไบต์

for(;$argv[1]%++$i<1;);echo$i;

ถ้าเรียกใช้จากคอนโซลด้วย-rตัวเลือก (ขอบคุณเพื่อ @ ais523)

php -r 'for(;$argv[1]%++$i<1;);echo$i;' 232792560

32 ไบต์

<?for(;$argv[1]%++$i<1;);echo$i;

ขอบคุณ @manatwork สำหรับการลบ 1 ไบต์

33 ไบต์ (ดั้งเดิม)

<?for(;$argv[1]%++$i==0;);echo$i;

Cubix , 14 12 ไบต์

I2/L/);?%<@O

บันทึก 2 ไบต์ด้วย MickyT

ลองมัน

คำอธิบาย

ในรูปแบบคิวบ์โค้ดคือ:

    I 2
    / L
/ ) ; ? % < @ O
. . . . . . . .
    . .
    . .

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

> <> , 15 +3 = 18 ไบต์

1\n;
?\1+:{:}$%

คาดว่าอินพุตจะอยู่ในสแต็กเมื่อเริ่มต้นโปรแกรมดังนั้นจึงมีค่า 3 ไบต์สำหรับ-vแฟล็ก ลองออนไลน์!

แมงกะพรุน , 12 10 ไบต์

p\~~|1
 >i

รับอินพุตจาก STDIN และเอาต์พุตไปยัง STDOUT ลองออนไลน์!

Martin Ender บันทึก 2 ไบต์ขอบคุณ!

คำอธิบาย

 \~~|
 >i

ส่วนนี้เป็นฟังก์ชันหนึ่งที่ใช้ค่าอินพุตในการกำหนด

   ~|

นี้~-cell จะได้รับฟังก์ชั่นจึงพลิกอาร์กิวเมนต์: ก่อฟังก์ชั่นฐาน "อาร์กิวเมนต์ซ้ายโมดูโล ( |) อาร์กิวเมนต์ที่ถูกต้อง" ฟังก์ชั่นแบบโมดูโลในตัวในแมงกะพรุนรับการโต้แย้งในลำดับที่กลับกัน

  ~~|
  i

~-cell นี้จะได้รับค่าและฟังก์ชั่นดังนั้นมันจึงใช้งานบางส่วน: มันผลิตฟังก์ชั่นไบนารี "input ( i) อาร์กิวเมนต์โมดูโลขวา" ขอเรียกว่าฟังก์ชั่นF

 \~~|
 >i

\-cell จะได้รับทั้งสองฟังก์ชั่นเพื่อให้มันไม่ซ้ำ: มันผลิตฟังก์ชั่นเอก "ที่เพิ่มขึ้น ( >) จนกระทั่งฟังก์ชั่นฉนำไปใช้กับค่าก่อนหน้านี้และปัจจุบันให้ truthy (ไม่ใช่ศูนย์) ผลแล้วกลับค่าปัจจุบัน" ซึ่งหมายความว่าอาร์กิวเมนต์จะเพิ่มขึ้นจนกว่าจะไม่แบ่งอินพุต

p\~~|1
 >i

สุดท้ายเราใช้ฟังก์ชั่นนี้เป็นค่าเริ่มต้นและพิมพ์ผลกับ1p