เขียนโค้ดที่เมื่อได้รับเป็นจำนวนบวก$x$เป็น input ออกผลลัพธ์เป็นตัวหารบวกที่ใหญ่ที่สุดของ$x$น้อยกว่าหรือเท่ากับรากที่สองของx$x$

ในคำอื่น ๆ หาที่ใหญ่ที่สุด$n > 0$เช่นนั้น

$\exists m\geq n:m\cdot n=x$

^{(มีอยู่$m$มากกว่าหรือเท่ากับ$n$เช่นที่$m$ครั้ง$n$คือ$x$ )}

ตัวอย่างเช่นถ้าใส่ได้$12$ตัวหารเป็น$1$ , $2$ , $3$ , $4$ , $6$และ12 1 , 2และ3ทั้งหมดคูณด้วยตัวเลขขนาดใหญ่ที่จะได้รับ12แต่3เป็นที่ใหญ่ที่สุดเพื่อให้เรากลับ3$12$$1$$2$$3$$12$$3$$3$

นี่คือรหัสกอล์ฟดังนั้นคำตอบจะได้คะแนนเป็นไบต์ด้วยจำนวนไบต์น้อยกว่าซึ่งถือว่าเป็นคะแนนที่ดีกว่า

กรณีทดสอบ

(1,1)
(2,1)
(3,1)
(4,2)
(5,1)
(6,2)
(7,1)
(8,2)
(9,3)
(10,2)
(11,1)
(12,3)
(13,1)
(14,2)
(15,3)
(16,4)
(17,1)
(18,3)
(19,1)
(20,4)
(21,3)
(22,2)
(23,1)
(24,4)
(25,5)
(26,2)
(27,3)
(28,4)
(29,1)
(30,5)
(31,1)
(32,4)
(33,3)
(34,2)
(35,5)
(36,6)
(37,1)
(38,2)
(39,3)
(40,5)
(41,1)
(42,6)
(43,1)
(44,4)
(45,5)
(46,2)
(47,1)
(48,6)
(49,7)
(50,5)

OEIS A033676

Python3 , 49 47 ไบต์

def f(x):
 l=x**.5//1
 while x%l:l-=1
 return l

คำอธิบาย

• l=x**.5//1 →กำหนด lจำนวนเต็มที่ใหญ่ที่สุดน้อยกว่าเท่ากับสแควร์รูทของx
• while x%l:l-=1→ในขณะที่lไม่เท่ากันแบ่งพร่องxl

การแก้ไข

• พูดถึง Python3 ไม่ใช่ Python2
• ใช้...//1เพื่อบันทึกสองไบต์ (ทศนิยมไม่เป็นไร! ขอบคุณ @Rod)

MATL , 7 ไบต์

Z\tn2/)

ลองออนไลน์!

สำหรับคำอธิบายนี้เราจะใช้ '12' เป็นตัวอย่างอินพุต คำอธิบาย:

Z\      % Divisors.
        % Stack:
        %   [1 2 3 4 6 12]
  t     % Duplicate.
        % Stack:
        %   [1 2 3 4 6 12]
        %   [1 2 3 4 6 12]
   n    % Number of elements.
        % Stack:
        %   6
        %   [1 2 3 4 6 12]
    2/  % Divide by 2
        % Stack:
        %   3
        %   [1 2 3 4 6 12]
      ) % Index (grab the 3rd element)
        % 3

งานนี้เกิดขึ้นเพราะมีความบังเอิญมากมาย

1. MATL ใช้การจัดทำดัชนี 1 รายการ
2. ถ้าเราทำดัชนีด้วยจำนวนที่ไม่ใช่จำนวนเต็ม (สิ่งนี้จะเกิดขึ้นสำหรับอินพุตสี่เหลี่ยมจัตุรัสที่สมบูรณ์แบบ) จากนั้น<n>)จะสร้างดัชนี$\lceil n \rceil$

C (gcc) -lm , 35 ไบต์

i;f(n){for(i=sqrt(n);n%i;i--);n=i;}

ลองออนไลน์!

05AB1E , 5 ไบต์

Ñ2äнθ

ลองออนไลน์! หรือเป็นชุดทดสอบ

คำอธิบาย

Ñ        # push the list of divisors
 2ä      # split it into 2 parts
   н     # take the first haft
    θ    # take the last element of that

APL (Dyalog Unicode) , 16 14 12 ไบต์

ฉันดีใจที่ฉันสามารถเขียนคำตอบใน APL เนื่องจากฉันเพิ่งเรียนรู้ ขอบคุณAdámมากสำหรับความช่วยเหลือเกี่ยวกับการเล่นกอล์ฟ คำแนะนำการเล่นกอล์ฟยินดีอย่างมากลองออนไลน์!

ต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ APL, ดูที่APL ออชาร์ด

แก้ไข: -2 ไบต์เพื่อแก้ไขปัญหาเกี่ยวกับรหัสของฉัน ขอบคุณ H.PWiz ที่ชี้ให้เห็นปัญหานั้น -2 ไบต์จากการย่อทุกอย่างอีกครั้ง

⌈/{⍳⌊⍵*÷2}∨⊢

Ungolfing

⌈/{⍳⌊⍵*÷2}∨⊢
          ∨   GCD of the following...
           ⊢    The right argument, our input.
  {⍳⌊⍵*÷2}
     ⍵            Our input.
      *÷2         To the power of 1/2, i.e. square root.
    ⌊             Floor.
   ⍳              Indices up to floor(sqrt(input)).
                In total, range from 1 to floor(sqrt(input)).
⌈/            The maximum of the GCDs of our input with the above range.

Husk , 4 ไบต์

→←½Ḋ

ลองออนไลน์!

คำอธิบาย

→←½Ḋ
   Ḋ      Divisors of (implicit) input.
  ½       Bisect.
→←        Take the last element of the first half.

R , 45 33 ไบต์

function(x,y=1:x^.5)max(y[!x%%y])

ลองออนไลน์!

เดิม:

function(x,y=x/1:x^.5)max(which(y==floor(y)))

ลองออนไลน์!

x86 รหัสเครื่อง 32 บิต (IA32): 18 16 ไบต์

changelog: จัดการn=1กรณีทดสอบอย่างถูกต้องบันทึก 2 ไบต์และส่งกลับใน EAX

นับจนถึง n/i <= i (เช่นเมื่อเราไปถึง sqrt) และใช้ตัวหารแรกที่แน่นอนหลังจากนั้น

เวอร์ชัน 64- บิตนี้สามารถเรียกได้จาก C พร้อมกับ x86-64 System V การเรียกประชุมเช่น
int squarish_root_countup(int edi)เรียกประชุมเป็น

nasm -felf32 -l/dev/stdout squarish-root.asm:

58                         DEF(squarish_root_countup)
59                             ; input: n in EDI
60                             ; output: EAX
61                             ; clobbers: eax,ecx,edx
62                         .start:
63 00000025 31C9               xor    ecx, ecx
64                         .loop:                    ; do{
65                         
66 00000027 41                 inc    ecx                ; ++i
67 00000028 89F8               mov    eax, edi
68 0000002A 99                 cdq
69 0000002B F7F9               idiv   ecx                ; edx=n%i    eax=n/i
70                         
71 0000002D 39C1               cmp    ecx, eax
72 0000002F 7CF6               jl     .loop          ; }while(i < n/i
73                                                   ;          || n%i != 0);  // checked below
74                             ; falls through for i >= sqrt(n)
75                             ; so quotient <= sqrt(n) if we get here
76                         
77                                                   ; test edx,edx / jnz  .loop
78 00000031 4A                 dec    edx            ; edx-1 is negative only if edx was zero to start with
79 00000032 7DF3               jge   .loop           ; }while(n%i >= 1);
80                             ; falls through for exact divisors
81                         
82                             ; return value = quotient in EAX
83                         
84 00000034 C3                 ret

           0x10 bytes = 16 bytes.

85 00000035 10             .size: db $ - .start

ลองออนไลน์! ด้วย asm caller ที่ใช้ไบต์แรกของ argv [1] เป็นจำนวนเต็มโดยตรงและใช้ผลลัพธ์เป็นสถานะทางออกของกระบวนการ

$ asm-link -m32 -Gd squarish-root.asm && 
for i in {0..2}{{0..9},{a..f}};do 
    printf "%d   " "0x$i"; ./squarish-root "$(printf '%b' '\x'$i)"; echo $?;
done

0   0  # bash: warning: command substitution: ignored null byte in input
1   1
2   1
3   1
4   2
5   1
6   2
7   1
8   2
9   3
10   0       # this is a testing glitch: bash ate the newline so we got an empty string.  Actual result is 2 for n=10
11   1
12   3
13   1
14   2
15   3
16   4
   ...

Japt -h, 8 6 ไบต์

â f§U¬

ลองมัน

บันทึก 2 ไบต์ขอบคุณOliver

คำอธิบาย

           :Implicit input of integer U
â          :Divisors of U
  f        :Filter
   §       :  Less than or equal to
    U¬     :  Square root of U
           :Implicitly get the last element in the array and output it

เยลลี่ 5 ไบต์

ọⱮ½TṪ

ลองออนไลน์!

JavaScript ES7, 33 31 ไบต์

n=>(g=x=>n%x?g(x-1):x)(n**.5|0)

ลองออนไลน์

Snowman , 38 ไบต์

((}1vn2nD`#nPnF|:|NdE|;:,#NMo*|,;bW*))

ลองออนไลน์!

((
  }        activate variables b, e, and g
  1vn2nD`  e=1/2
  #        retrieve the input into b
  nP       set b=b^e, which is sqrt(input)
  nF       floor the square root
  |        move b into g so there's space for a while loop
  :        body of the loop
    |NdE|  decrement the value in g
  ;:       loop condition
    ,#     assign b=input, e=current value
    NMo    store the modulo in g
    *|     discard the input value and place the modulo in the condition slot
    ,      put the current value back into g
  ;bW      continue looping while the modulo is nonzero
  *        return the result
))

dc , 24

?dsnv1+[1-dlnr%0<m]dsmxp

ลองออนไลน์!

คำอธิบาย:

?                         # read input
 d                        # duplicate
  sn                      # store copy 1 in register n
    v                     # take the square root of copy 2
     1+                   # add 1
       [          ]       # define macro to:
        1-                #   subtract 1
          d               #   duplicate
           ln             #   load from register n
             r            #   reverse top 2 stack members
              %           #   calculate modulo
               0<m        #   if not 0, recursively call macro m again
                   d      # duplicate macro
                    sm    # store copy 1 in register m
                      x   # execute copy 2
                       p  # print final value

J, 24 19 ไบต์

-5 ไบต์ขอบคุณแนวคิด GCD ของ Sherlock

([:>./+.)1+i.@<.@%:

ลองออนไลน์!

คำตอบเดิม

([:{:]#~0=]|[)1+i.@<.@%:

ลองออนไลน์!

แจง

┌───────────────────────────────┬──────────────────────┐
│┌──┬──┬───────────────────────┐│┌─┬─┬────────────────┐│
││[:│{:│┌─┬─────┬─────────────┐│││1│+│┌─────────┬─┬──┐││
││  │  ││]│┌─┬─┐│┌─┬─┬───────┐││││ │ ││┌──┬─┬──┐│@│%:│││
││  │  ││ ││#│~│││0│=│┌─┬─┬─┐│││││ │ │││i.│@│<.││ │  │││
││  │  ││ │└─┴─┘││ │ ││]│|│[││││││ │ ││└──┴─┴──┘│ │  │││
││  │  ││ │     ││ │ │└─┴─┴─┘│││││ │ │└─────────┴─┴──┘││
││  │  ││ │     │└─┴─┴───────┘│││└─┴─┴────────────────┘│
││  │  │└─┴─────┴─────────────┘││                      │
│└──┴──┴───────────────────────┘│                      │
└───────────────────────────────┴──────────────────────┘

คำอธิบาย

• 1 + i.@<.@%: ให้ช่วง 1 .. floor(sqrt)จะช่วยให้ช่วง
• คำกริยาทั้ง(A) Bรูปเป็นตะขอโดยมีช่วงเหนือผ่านไปเป็น ARG ทางขวา]และหมายเลขเดิมส่งผ่านเป็น ARG ด้านซ้าย[และหมายเลขเดิมผ่านเป็นหาเรื่องซ้าย ดังนั้น...
• ] | [ ให้ส่วนที่เหลือของแต่ละรายการในช่วงแบ่งออกเป็นหาเรื่องดั้งเดิม
• และ 0 = ] | [ให้ divisors โดยไม่เหลือ
• ] #~ ... จากนั้นกรองช่วงออกจากรายการเหล่านั้นเท่านั้น
• และ{:ให้รายการสุดท้ายในรายการคือรายการที่ใหญ่ที่สุด

เยลลี่ 5 ไบต์

½ḍƇµṪ

ลองออนไลน์!

Haskell , 36 ไบต์

f x=[z|y<-[1..],z<-[1..y],y*z==x]!!0

ลองออนไลน์!

นี่คือคำตอบของฉันสำหรับความท้าทายนี้ สิ่งนี้ใช้ความเข้าใจในรายการเฉพาะเพื่อค้นหาคำตอบ ในรายการความเข้าใจของเราที่เราเลือก$y$จากรายการอนันต์[1..]ที่เป็นจำนวนเต็มบวกและเราเลือก$z$[1..y]จากรายการ ซึ่งหมายความว่า$(y,z)$ เป็นคู่ที่สั่งซื้อทั้งหมดเช่นนั้น $y \geq z$.

จากนั้นเราเลือกเฉพาะคู่เหล่านั้นเช่นนั้น $y\cdot z=x$หมายถึงเราทำรายการของตัวเลขทั้งหมดที่คูณด้วย $x$. ตอนนี้เนื่องจากความเข้าใจของเราขึ้นอยู่กับ$y$ แล้ว $z$ นี่หมายความว่าคู่ของเราอยู่ในลำดับที่มากขึ้น $y$หรือมากกว่ามีประโยชน์ตามลำดับจากมากไปน้อยของ $z$.

ดังนั้นเพื่อให้ได้ขนาดที่ใหญ่ที่สุด $z$ พวกเรารับ $z$เป็นขององค์ประกอบแรก นี่คือผลลัพธ์ของเรา

QBasic (4.5), 52 ไบต์

INPUT x
FOR i=1TO sqr(x)
if x/i=x\i then m=i
next
?m

Forth (gforth) , 53 ไบต์

วิธีที่สั้นที่สุดดูเหมือนว่าจะใช้ stack point floating และfsqrtสั้นที่สุดที่ฉันจะได้รับหากไม่มี 62 bytes ใช้/modและตรวจสอบว่าผลหารมีค่ามากกว่าตัวหารหรือไม่

: f dup s>f fsqrt f>s 1+ begin 1- 2dup mod 0= until ;

ลองออนไลน์!

คำอธิบาย

1. คำนวณสแควร์รูท
2. เริ่มต้นที่สแควร์รูท, ลดลง 1 จนกว่าเราจะพบปัจจัยของจำนวนเดิม

รหัสคำอธิบาย

: f                \ Start a word definition
dup                \ duplicate the input
s>f fsqrt          \ move the number to the float stack and get the square root
f>s                \ truncate result and move to integer stack
1+                 \ add 1 to the square root
begin              \ start indefinite loop
  1- 2dup          \ decrement divisor and duplicate input and divisor
  mod              \ calculate n % divisor
0= until           \ if result equals 0 (no remainder) end the loop
;                  \ end the word definition

F#, 55 49 bytes

let f x=Seq.findBack(fun i->x%i=0.0){1.0..x**0.5}

Try it online!

Seq.findBack: Returns the last element for which the given function returns True. The function in this case checks to see if a number is a factor of the value.

Brain-Flak, 144 bytes

{({}{}<<>({}<>)<>([({})()]<>({}(<>)())){(<{}({}[()]{}<({}())>)>)}{}((({}<>)<>(({})))[({}[{}])])>[({<({}[()])><>({})<>}{}<><{}>)])}{}{}<>{}({}<>)

Try it online!

I'm not really sure this answer is very good. I feel like there may be a nice way to solve this task however I'm just not clever enough.

Explanation

I tried to do an exploded view of the answer but there are so many moving parts it was not very enlightening, so here is an explanation of what the code does.

The first important bit is this

({}<>)<>([({})()]<>({}(<>)())){(<{}({}[()]{}<({}())>)>)}{}

This takes the two numbers on top of the stack and if they are unequal increments the second one, if they are equal it increments the first one and replaces the second one with zero. If we repeat this code a bunch we will get all the pairs $(x,y)$ such that $x \geq y$.

The next part is multiplication, taken with modification from the wiki. This multiplication is special because it preserves the existing values without destroying them. It goes like:

((({}<>)<>(({})))[({}[{}])])({<({}[()])><>({})<>}{}<><{}>)

So we are multiplying all these ordered pairs. For each result we check if it is equal to the input. If so we terminate and return the smaller item in the pair.

Python 2, 41 bytes

n=k=input()
while(k*k>n)+n%k:k-=1
print k

Try it online!

Jelly, 6 bytes

ÆDŒHḢṪ

Try it online!

Perl 5 -p, 26 bytes

$\=0|sqrt;$\--while$_%$\}{

Try it online!

Rust, 71 70 bytes

fn f(x:u64)->u64{let mut l=(x as f64).sqrt()as u64;while x%l>0{l-=1}l}

Pre-uglified version

fn f(x: u64) -> u64 {                    // function takes u64, gives u64
  let mut l = (x as f64).sqrt() as u64;  // l takes integer'ed root value
  while x % l > 0 {                      // loop while l leaves remainder
    l -= 1                               // decrement
  }
  l                                      // return the found value
}

Edits

• Save a byte with > 0 over != 0. (Thanks to @CatWizard)

Japt, 8 bytes

â w æ§Uq

Try it online!

Triangularity, 49 bytes

....)....
...@_)...
..IEdF)..
.2)1/)IE.
^>{m.....

Try it online!

Pyret, 93 bytes

{(z):rec f={(i,x):if num-modulo(i, x) == 0:x else:f(i,x - 1)end}
f(z,num-floor(num-sqrt(z)))}

You can try this online by copying it into the online Pyret editor!

The above evaluates to an anonymous function. When it is applied to an integer, it returns a result according to the specification.

Actually, 7 bytes

Based on my APL answer here. Golfing suggestions welcome! Try it online!

;√LR♀gM

Ungolfing

;√LR♀gM  Implicit input n
;        Duplicate n
 √       sqrt(n)
  L      floor(sqrt(n))
   R     1..floor(sqrt(n))
    ♀g   gcd(n, foreach(1..floor(sqrt(n)))
      M  The maximum of the GCDs.
         Return this maximum.

A port of this Mathematica answer.

Jelly, 11 bytes

½ðḞ³÷Ċ³÷µÐL

Try it online!

This (11 bytes) also works, and don't depend on ³:

½Ḟ÷@Ċ÷@ʋƬµṪ

Unfortunately ½Ḟ÷@Ċ÷@ʋÐL (10 bytes) doesn't work. And apparently Ƭ and ÐĿ is not exactly the same (when the link is dyadic)

Method: (let $n$ be the input)

• Start with an upper bound $i = \sqrt n$ of the answer $a$.
• At each step:
  • If $i$ is not an integer, then the upper bound can be made $\lfloor i\rfloor$ (because the result must be an integer)
  • If $n\over i$ is not an integer, then $a \le i \Rightarrow \frac n a \ge \frac n i \Rightarrow \frac n a \ge \lceil \frac n i \rceil \Rightarrow a \le n \div \lceil \frac n i \rceil$.
• So we repeatedly replace $i$ with $n \div \lceil \frac n {\lfloor i\rfloor} \rceil$ until it's fixed.

Java 8, 65 54 bytes

n->{int r=(int)Math.sqrt(n);for(;n%r>0;r--);return r;}

Port of @hunteke's Python 3 answer.

Try it online.

Old 65 bytes answer:

n->{int r=1,i=n;for(;i-->1;)r=n%i<1&n/i<=i&n/i>r?n/i:r;return r;}

Try it online.

Explanation:

n->{                // Method with integer as both parameter and return-type
  int r=1,          //  Result-integer, starting at 1
  i=n;for(;i-->1;)  //  Loop `i` in the range (n, 1]
    r=n%i<1         //   If `n` is divisible by `i`,
      &n/i<=i       //   and if `n` divided by `i` is smaller than or equal to `i` itself,
      &n/i>r?       //   and if `n` divided by `i` is larger than the current `r`
       n/i          //    Set `n` divided by `i` as the new result `r`
      :             //   Else:
       r;           //    Leave result `r` unchanged
  return r;}        //  Return the result `r`