จำนวนภาษาการเขียนโปรแกรมสร้างจำนวนเต็มขนาดใหญ่ผ่าน 'การต่อข้อมูล' ตัวเลขจนถึงจุดสิ้นสุดของจำนวนที่มีอยู่ ยกตัวอย่างเช่นเขาวงกตหรือปรับ ด้วยการต่อตัวเลขกับจุดสิ้นสุดฉันหมายถึงว่าถ้าจำนวนที่มีอยู่คือ$45$และหลักคือ$7$ผลลัพธ์จะเป็น$457\:(45 \times 10 + 7)$ )

ตัวเลขที่สร้างคือจำนวนที่สามารถสร้างวิธีนี้ผ่านการใช้ทวีคูณของตัวเลขหลักเดียว: , $1, 2, 3, 4, 5, 6, 7, 8, 9$ AKA องค์ประกอบในหนึ่งใน 9 ลำดับดังนี้:

เพื่อให้ตัวอย่างของวิธีการลำดับมีการสร้างที่นี่เป็นวิธีลำดับสำหรับ= 3ในการสร้าง:$a = 3$

_{$u_{33}$และ$u_{34}$รวมแสดงให้เห็นถึงเมื่อ$n \times a \ge 100$ 100 มีจุดจำนวนมากเพื่อเว้นวรรค}

อาจยังไม่ชัดเจนว่าลำดับเหล่านี้ถูกสร้างขึ้นอย่างไรดังนั้นนี่คือสองวิธีที่แตกต่างกันในการทำความเข้าใจ:

• แต่ละลำดับเริ่มต้นจากหลักเดียว พบคำต่อไปโดยการคูณหลายหลักถัดไปของการคูณคำก่อนหน้าด้วย$10$และเพิ่มหลายตัว ในแง่ของลำดับ:

  $$u_n = 10 \times u_{n-1} + n \times a, \: \: u_1 = a$$

  โดยที่$a$คือตัวเลขหลักเดียว ( $1$ถึง$9$ )

• แต่ละ$9$องค์ประกอบที่จุดใด ๆ ในลำดับ (ใช้$n = 3$เป็นต้น) เป็นทวีคูณของ$123\dots$จาก$1$ที่จะ$9$ที่$123\dots$ถูกสร้างโดย$u_{n+1} = 10 \times u_n + n$ $(1, 12, 123, \dots, 123456789, 1234567900, 12345679011, \dots)$

  ดังนั้นค่าแรกคือ$1 \times 1, 2, 3, \dots, 8, 9$ , ส่วนที่สองคือ$12 \times 1, 2, 3, \dots, 8, 9$ , $123 \times 1, 2, 3, \dots, 8, 9$ฯลฯ

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

คุณอาจป้อนข้อมูลในลักษณะที่สมเหตุสมผลรวมถึงรายการตัวเลขเป็นสตริง ฯลฯ เป็นที่ยอมรับได้ (แต่ไม่แนะนำให้ใช้) เพื่อป้อนข้อมูลแบบไม่พร้อมเพรียงหรือฐานอื่น ๆ ที่คุณเลือก

นี่คือรหัสกอล์ฟเพื่อให้ได้รหัสที่สั้นที่สุดชนะ!

กรณีทดสอบ

       u_n        => a
 37035            => 3
 6172839506165    => 5
 5                => 5
 246913580244     => 2
 987654312        => 8
 61728395061720   => 5
 1111104          => 9
 11111103         => 9
 111111102        => 9
 2469134          => 2
 98760            => 8
 8641975308641962 => 7

หรือเป็นสองรายการ:

[37035, 6172839506165, 5, 246913580244, 987654312, 61728395061720, 1111104, 11111103, 111111102, 2469134, 98760, 8641975308641962]
[3, 5, 5, 2, 8, 5, 9, 9, 9, 2, 8, 7]

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

05AB1E , 7 5 4 ไบต์

>9*н

ลองออนไลน์!

>            # input + 1
 9*          # * 9
   н         # take the first digit

MathGolfขนาด 6 ไบต์

)9*▒├Þ

ลองออนไลน์!

น่าเสียดายที่headMathGolf ไม่มีการใช้งานดังนั้นฉันต้องทำการ▒├Þแปลงให้เป็นสตริงดึงขึ้นมาจากด้านซ้ายแล้วทิ้งทั้งหมดยกเว้นส่วนบนสุดของสแต็ก

เยลลี่ 5 ไบต์

‘×9DḢ

ลองออนไลน์!

โดยใช้วิธีการสกปรกของ

Stax , 5 ไบต์

^9*Eh

เรียกใช้และแก้ไขข้อบกพร่อง

Japt -g , 7 6 5 ไบต์

-1 ไบต์ขอบคุณ Shaggy

รับอินพุตเป็นสตริง

i°U*9

ลองมัน | ทดสอบหลายอินพุต

ถ่าน 7 ไบต์

§Ｉ×⁹⊕Ｎ⁰

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด แน่นอนว่าวิธีการของ Grimy นี่คือวิธีการทางคณิตศาสตร์ 27 ไบต์:

ＮθＷ¬№Ｅχ×κ↨υχθ⊞υＬυＩ⌕Ｅχ×ι↨υχθ

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด เกิดปัญหากับอินพุตที่ไม่ถูกต้อง คำอธิบาย:

Ｎθ

ป้อนหมายเลขที่สร้าง

Ｗ¬№Ｅχ×κ↨υχθ

ตีความรายการเป็นตัวเลขในฐาน 10 คูณด้วยตัวเลขทั้งหมดจาก0ถึง9และดูว่าหมายเลขที่สร้างขึ้นปรากฏขึ้นหรือไม่

⊞υＬυ

ผลักดันความยาวของรายการเพื่อตัวเอง [0, 1, 2, ..., n]รายการจึงกลายเป็นของแบบฟอร์ม

Ｉ⌕Ｅχ×ι↨υχθ

สร้างตัวเลขที่สร้างขึ้นใหม่ แต่คราวนี้ค้นหาและส่งออกดัชนีซึ่งมีหมายเลขอินพุตปรากฏขึ้น

เขาวงกต ,  28 22  20 ไบต์

9 10/;!@
? _ :
)*"""

ใช้วิธีการตามตัวเลขที่อธิบายโดย Grimyโดยการหารจำนวนเต็มซ้ำสิบครั้งจนกระทั่งพบศูนย์

ลองออนไลน์!

ช่องว่าง 108 ไบต์

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input][S S S T    N
_Push_1][T  S S S _Add][S S S T S S T   N
_Push_9][T  S S N
_Multiply][S S S T  N
_Push_1][N
S S N
_Create_Label_LOOP][S S S T S T S N
_Push_10][T S S N
_Multiply][S N
S _Duplicate][S T   S S S T S N
_Copy_0-based_2nd]S N
T   Swap_top_two][T S S T   _Subtract][N
T   T   S N
_If_neg_jump_to_Label_PRINT][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_PRINT][S S S T    S T S N
_Push_10][T S T S _Integer_divide][T    S T S _Integer_divide][T    N
S T _Output_top_as_number]

เพิ่มตัวอักษรS(ช่องว่าง), T(แท็บ) และN(บรรทัดใหม่) เป็นการเน้นเท่านั้น
[..._some_action]เพิ่มเป็นคำอธิบายเท่านั้น

คำตอบ05AB1Eของพอร์ตของ@Grimyยกเว้นว่าฉันไม่มี builtin เพื่อรับตัวเลขตัวแรก ;)

ลองใช้ออนไลน์ (ด้วยพื้นที่ว่างเปล่าแท็บและบรรทัดใหม่เท่านั้น)

คำอธิบายในรหัสเทียม:

Integer i = STDIN as integer
i = i + 1
i = i * 9
Integer t = 1
Start LOOP:
  t = t * 10
  If(i - t < 0):
    Call function PRINT
  Go to next iteration of LOOP

function PRINT:
  t = t / 10
  i = i / t    (NOTE: Whitespace only has integer-division)
  Print i as integer to STDOUT

Python 3 , 22 ไบต์

lambda i:str(-~i*9)[0]

ลองออนไลน์!

ท่าเรือสกปรก 's คำตอบ 05AB1E

Python 3 , 74 ไบต์

f=lambda i,j=1,k=2,l=1:l*(i==j)or f(i,*(10*j+k*l,l+1,k+1,2,l,l+1)[i<j::2])

ลองออนไลน์!

คำอธิบาย

ฟังก์ชั่นวนซ้ำ iterates กว่าลำดับสำหรับแต่ละหลักเริ่มต้นที่l 1หากอินพุตiเท่ากับการวนซ้ำปัจจุบันjตัวเลขที่สอดคล้องกันlจะถูกส่งคืน มิฉะนั้นหากค่าปัจจุบันjในลำดับเกินกว่าค่าอินพุตiมันจะเพิ่มจำนวนหลักlและเริ่มต้นใหม่ อาร์กิวเมนต์ที่kใช้ในการเพิ่มปัจจัยการคูณ

JavaScript (ES6),  16  15 ไบต์

ขอบคุณ @Grimy สำหรับการยกข้อ จำกัด แบบ 32 บิตที่ฉันมีกับรุ่นก่อนหน้า

การใช้คาถามนต์ขลังของสกปรก รับอินพุตเป็นสตริง

n=>(n*9+9+n)[0]

ลองออนไลน์!

JavaScript (ES6), 53 ไบต์

วิธีการบังคับเดรัจฉานไร้เดียงสา

n=>(g=(k,x=i=0)=>x>n?g(k+1):x<n?g(k,++i*k+10*x):k)(1)

ลองออนไลน์!

Java 8, 23 ไบต์

n->(n*9+9+"").charAt(0)

คำตอบ05AB1Eของพอร์ตของ@Grimyดังนั้นอย่าลืม upvote เขา!

ลองออนไลน์

แต่เนื่องจากฉันรู้สึกไม่ดีกับ@cairdCoinheringaahingนี่เป็นวิธีการที่โหดเหี้ยมและจ่ายได้มากกว่า ( 83 ไบต์ ):

n->{long r=n,a=0,u,k;for(;++a<10;r=u>n?r:a)for(k=2,u=a;u<n;)u=u*10+k++*a;return r;}

ลองออนไลน์

คำอธิบาย:

n->{                 // Method with long as both parameter and return-type
  long r=n,          //  Result, starting at the input in case it's already a single digit
       a=0,          //  The digit to start the sequence with
       u,            //  The last number of the sequence we're building for digit a
       k;            //  Multiplier which increments each iteration
  for(;++a<10;       //  Loop in the range [1,9] (over each digit):
      r=u>n?         //    After ever iteration: if `u` is larger than the input:
            r        //     Keep the result the same
           :         //    Else:
            a)       //     Change the result to `a`
    for(k=2,         //   Reset `k` to 2
        u=a;         //   Reset `u` to the current digit `a`
        u<n;)        //   Inner loop as long as `u` is smaller than the input
      u=             //    Change `u` to:
        u*10         //     10 times the current `u`
            +k++*a;  //     With `k` multiplied by `a` added
                     //     (after which `k` increases by 1 with `k++`)
  return r;}         //  And after we iterated over each digit, return the result

PHP , 20 ไบต์

<?=(_.++$argn*9)[1];

ลองออนไลน์!

ยังเป็นอีกพอร์ตคำตอบของ Grimy !

เยลลี่ 8 ไบต์

RRḌ÷@fⱮ9

ลองออนไลน์!

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

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

DJRḌ÷@fⱮ9

ลองออนไลน์!

Hy , 44 ไบต์

(defn a[p](print(get(str(*(+(int p)1)9))0)))

ใช้วิธีการของ Grimy

ลองออนไลน์!

Keg -rrขนาด 4 ไบต์

⑨9*÷

ลองออนไลน์!

แน่นอนใช้วิธีเดียวกันกับคำตอบ 05AB1E ใช้การ-rrตั้งค่าสถานะใหม่(ย้อนกลับและพิมพ์ดิบ)

ส่งไปที่:

from KegLib import *
from Stackd import Stack
stack = Stack()
printed = False
increment(stack)
integer(stack, 9)
maths(stack, '*')
item_split(stack)
if not printed:
    reverse(stack)
    raw(stack)

เรน 30 ไบต์

เพียงแค่พอร์ตคำตอบส่วนใหญ่

Fn.new{|i|(i*9+9).toString[0]}

ลองออนไลน์!