ภาษา J มีไวยากรณ์โง่มากสำหรับการระบุค่าคงที่ ฉันต้องการที่จะมุ่งเน้นไปที่คุณสมบัติที่ยอดเยี่ยมโดยเฉพาะอย่างยิ่ง: ความสามารถในการเขียนบนฐานโดยพลการ

ถ้าคุณเขียนXbYสำหรับXจำนวนใด ๆ และYสตริงของ Alphanumerics ใด ๆ แล้วเจจะแปลYเป็นฐานXจำนวนที่0ผ่าน9มีความหมายปกติของพวกเขาและaผ่านzตัวแทนที่ 10 ถึง 35

และเมื่อฉันพูดXหมายเลขใด ๆ ฉันหมายถึงหมายเลขใด ๆ สำหรับจุดประสงค์ของคำถามนี้ฉันจะบังคับXให้เป็นจำนวนเต็มบวก แต่ใน J คุณสามารถใช้อะไรก็ได้: จำนวนลบ, เศษส่วน, จำนวนเชิงซ้อนหรืออะไรก็ตาม

สิ่งที่แปลกก็คือว่าคุณสามารถใช้ตัวเลข 0-35เป็นฐานสิ่งที่คุณตัวเลขเพราะเก็บของสัญลักษณ์ที่ใช้งานได้ประกอบด้วยเพียง 0-9 และ az

ปัญหา

ฉันต้องการโปรแกรมที่ช่วยฉันเกี่ยวกับมายากลเลขกอล์ฟเช่น2,933,774,030,998โดยใช้วิธีนี้ โอเคอาจจะไม่ใหญ่ขนาดนั้นฉันจะไปง่ายสำหรับคุณ ดังนั้น...

งานของคุณคือการเขียนโปรแกรมหรือฟังก์ชั่นซึ่งจะใช้เวลา (โดยปกติขนาดใหญ่) เลขทศนิยมNระหว่าง 1 และ 4294967295 (= 2 ³² -1) เป็น input และผล / ผลตอบแทนที่เป็นตัวแทนที่สั้นที่สุดของรูปแบบXbYที่Xเป็นจำนวนเต็มบวกYเป็น สตริงประกอบด้วย Alphanumerics (0-9 และ az, กรณีตาย) และYตีความในฐานเท่าเทียมกันXN

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

นี่คือรหัสกอล์ฟดังนั้นจึงสั้นกว่าดีกว่า

กรณีทดสอบ

      Input | Acceptable outputs (case-insensitive)
------------+-------------------------------------------------------
          5 | 5
            |
   10000000 | 79bkmom  82bibhi  85bgo75  99bauua  577buld
            | 620bq9k  999baka
            |
   10000030 | 85bgo7z
            |
   10000031 | 10000031
            |
   12345678 | 76bs9va  79bp3cw  82bmw54  86bjzky  641buui
            |
   34307000 | 99bzzzz
            |
   34307001 | 34307001
            |
 1557626714 | 84bvo07e  87brgzpt  99bglush  420blaze
            |
 1892332260 | 35bzzzzzz  36bvan8x0  37brapre5  38bnxkbfe  40bij7rqk
            | 41bgdrm7f  42bek5su0  45bablf30  49b6ycriz  56b3onmfs
            | 57b38f9gx  62b244244  69b1expkf  71b13xbj3
            |
 2147483647 | 36bzik0zj  38br3y91l  39bnvabca  42bgi5of1  48b8kq3qv
 (= 2^31-1) | 53b578t6k  63b2akka1  1022b2cof  1023b2661  10922bio7
            | 16382b8wv  16383b8g7  32764b2gv  32765b2ch  32766b287
            | 32767b241
            |
 2147483648 | 512bg000  8192bw00
            |
 4294967295 | 45bnchvmu  60b5vo6sf  71b2r1708  84b12mxf3  112brx8iv
 (= 2^32-1) | 126bh5aa3  254b18owf  255b14640  1023b4cc3  13107bpa0
            | 16383bgwf  21844b9of  21845b960  32765b4oz  32766b4gf
            | 32767b483  65530b1cz  65531b1ao  65532b18f  65533b168
            | 65534b143  65535b120

หากคุณไม่แน่ใจเกี่ยวกับว่าเป็นตัวแทนบางส่วนจะเท่ากับจำนวนบางอย่างที่คุณสามารถใช้ล่าม J ใดอย่างหนึ่งในลองออนไลน์ เพียงพิมพ์stdout 0":87brgzptและ J จะพ่นออก1557626714ไป โปรดทราบว่า J ยอมรับเฉพาะตัวพิมพ์เล็กเท่านั้นแม้ว่าปัญหานี้จะไม่ตรงตามตัวพิมพ์ใหญ่และตัวพิมพ์เล็ก

บางทฤษฎีอาจเป็นประโยชน์

• สำหรับทั้งหมดที่Nน้อยกว่า 10,000,000 การแทนค่าทศนิยมจะสั้นเหมือนกันและด้วยเหตุนี้จึงเป็นเอาต์พุตที่ยอมรับได้เท่านั้น หากต้องการบันทึกสิ่งใดก็ตามคุณจะต้องมีตัวเลขอย่างน้อยสี่หลักในฐานใหม่และยิ่งถ้าฐานมากกว่า 99
• Nมันพอเพียงในการตรวจสอบฐานถึงเพดานของรากที่สองของ สำหรับท่านใดที่มีขนาดใหญ่ฐานB , Nจะอยู่ที่ส่วนใหญ่ตัวเลขสองหลักในฐานBจึงเป็นครั้งแรกที่คุณจะได้รับสิ่งที่มีหลักแรกที่ถูกต้องที่ประมาณB ≈ N/ 35 แต่ด้วยขนาดนั้นคุณจะต้องมีขนาดใหญ่เท่ากับการแทนค่าทศนิยมอย่างน้อยเสมอดังนั้นจึงไม่มีประโยชน์ในการลอง ที่ในใจ ceil (sqrt (จำนวนมากที่สุดฉันจะขอให้คุณแก้ปัญหานี้)) = 65536
• หากคุณมีการแสดงใด ๆ ในฐานที่น้อยกว่า 36 การแสดงพื้นฐาน 36 นั้นจะต้องสั้นที่สุด ดังนั้นคุณไม่ต้องกังวลเกี่ยวกับการแก้ปัญหาระยะสั้นโดยไม่ตั้งใจในฐานที่น้อยกว่า 36 ตัวอย่างเช่นการแทน35bzzzzzzค่า 1,892,332,260 ใช้ตัวเลขที่ผิดปกติสำหรับฐานนั้น แต่36bvan8x0มีความยาวเท่ากัน

JavaScript (ES6), 103 101 ไบต์

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

n=>[...Array(7e4)].reduce(p=>p[(r=++b+(g=x=>x?g(x/b|0)+(x%b).toString(36):'b')(n)).length]?r:p,n,b=2)

กรณีทดสอบ

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

let f =

n=>[...Array(6e2)].reduce(p=>p[(r=++b+(g=x=>x?g(x/b|0)+(x%b).toString(36):'b')(n)).length]?r:p,n,b=2)

console.log(f("5"))
console.log(f("10000000"))
console.log(f("10000030"))
console.log(f("10000031"))
console.log(f("12345678"))
console.log(f("34307000"))
console.log(f("34307001"))
console.log(f("1557626714"))
console.log(f("1892332260"))
console.log(f("2147483647"))
console.log(f("2147483648"))
console.log(f("4294967295"))

ทับทิม 118 ไบต์

นี่เชื่อมโยงกับคำถามอื่นและฉันสังเกตเห็นว่ามีคำตอบไม่มากที่นี่ดังนั้นฉันจึงตัดสินใจที่จะให้มัน

เดินผ่านฐานทั้งหมดจนถึงและรวมอินพุตเพื่อสร้างโครงสร้างตัวเลข J ที่ถูกต้องทั้งหมด มันข้ามไป 1-8 เนื่องจากไม่มีวิธีที่จะสั้นกว่าการแสดงพื้นฐาน 10 แต่อย่างใด มันเป็นคำตอบที่ไร้เดียงสาทุกสิ่งที่เราพิจารณาเพราะมันเรียกว่าdigitsbuiltin เพื่อให้ได้ตัวเลข แต่เนื่องจากนั่นเริ่มต้นด้วยตัวเลขที่มีนัยสำคัญน้อยที่สุดก่อนอื่นเราต้องให้reverseมันได้จำนวนจริงดังนั้นมันอาจจะดีขึ้น

มันช้า ดังนั้นช้ามากอย่างไม่น่าเชื่อ TIO หมดเวลาใน 34307000 เช่น เราสามารถไปกับสแควร์รูทหรือแม้กระทั่งตัวเลือกของ Arnauld ที่7e4จะประหยัดเวลา แต่มีค่าใช้จ่ายเพิ่มเป็นไบต์ดังนั้นทำไมต้องกังวล

->n{([n.to_s]+(9..n).map{|b|d=n.digits b;"#{b}b"+d.reverse.map{|i|i.to_s 36}*''if d.all?{|i|i<36}}-[p]).min_by &:size}

ลองออนไลน์!

ลองใช้งานออนไลน์ด้วย sqrt เพื่อให้ทุกอย่างเสร็จตรงเวลา

05AB1E , 37 ไบต์

[¼35ݾãvtîEyNβQižhA«yèJ'bìNìDgIg@i\}q

10000000ã$\geq4$

หากไม่มีคำสั่ง if ขั้นสุดท้ายDgIg@i\}จะยังคงสามารถทดสอบค่าที่ต่ำกว่าได้เพื่อตรวจสอบว่าใช้งานได้จริง: ลองออนไลน์

จะดูว่าฉันสามารถหาวิธีแก้ปัญหาที่มีประสิทธิภาพมากกว่านี้ได้ไหม

คำอธิบาย:

[              # Start an infinite loop:
 ¼             #  Increase the counter variable by 1 (0 by default)
 35Ý           #  Push a list in the range [0, 35]
 ¾ã            #  Take the cartesian product of this list with itself,
               #  with chunks-sizes equal to the counter variable
 v             #  Loop `y` over each of these lists:
  t            #   Take the square-root of the (implicit) input-integer
   î           #   Ceil it
  E            #   Loop `N` in the range [1, ceil(square(input))]:
   yNβ         #    Convert list `y` to base-`N`
   Qi          #    If it's equal to the (implicit) input-integer:
     žh        #     Push string "0123456789"
       A«      #     Append the lowercase alphabet
     yè        #     Index each value in list `y` into this string
     J         #     Join the characters to a single string
     'bì      '#     Prepend a "b"
        Nì     #     Prepend the number `N`
     D         #     Duplicate it
      g        #     And pop and push the length of this string
       Ig      #     Also push the length of the input
         @i }  #     If the length of the string is >= the input-length:
           \   #      Discard the duplicated string
     q         #     Stop the program
               #     (after which the result is output implicitly;
               #      or if the string was discarded and the stack is empty, it will
               #      implicitly output the implicit input as result instead)