Viết mã khi cho số dương làm đầu vào, xuất ra ước số dương lớn nhất của nhỏ hơn hoặc bằng căn bậc hai của .x $x$$x$$x$

Nói cách khác, tìm lớn nhất sao cho$n > 0$

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

^{(Tồn tại lớn hơn hoặc bằng sao cho lần là )$m$$n$$m$$n$$x$}

Ví dụ: nếu đầu vào là thì các ước là , , , , và . , và tất cả nhân với số lớn hơn để có được , nhưng là lớn nhất nên chúng ta trả về .$12$$1$$2$$3$$4$$6$$12$$1$$2$$3$$12$$3$$3$

Đây là môn đánh gôn, vì vậy câu trả lời sẽ được tính bằng byte với ít byte hơn được coi là điểm tốt hơn.

Các trường hợp thử nghiệm

(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 byte

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

Giải trình

• l=x**.5//1→ Gán lsố nguyên lớn nhất nhỏ hơn bằng căn bậc hai củax
• while x%l:l-=1→ Trong khi lkhông chia đều x, giảm dần l.

Chỉnh sửa

• Đề cập Python3, không phải Python2
• Sử dụng ...//1để lưu hai byte. (Số thập phân không sao! Cảm ơn @Rod)

MATL , 7 byte

Z\tn2/)

Hãy thử trực tuyến!

Đối với lời giải thích này, chúng tôi sẽ sử dụng '12' làm đầu vào mẫu. Giải trình:

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

Điều này hoạt động vì rất nhiều sự trùng hợp may mắn.

1. MATL sử dụng 1 chỉ mục
2. Nếu chúng ta chỉ có một tổ chức phi nguyên (điều này sẽ xảy ra đối với bất kỳ đầu vào vuông hoàn hảo), sau đó <n>)sẽ index $\lceil n \rceil$

C (gcc) -lm , 35 byte

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

Hãy thử trực tuyến!

05AB1E , 5 byte

Ñ2äнθ

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

Ñ        # 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 byte

Tôi rất vui vì tôi đã có thể viết một số câu trả lời trong APL vì tôi chỉ mới học nó. Rất, rất cám ơn Adám đã giúp đỡ chơi golf. Gợi ý chơi golf rất được chào đón. Hãy thử trực tuyến!

Để tìm hiểu thêm về APL, hãy xem The APL Orchard .

EDIT: -2 byte để khắc phục sự cố với mã của tôi. Cảm ơn H.PWiz đã chỉ ra vấn đề đó. -2 byte từ rút ngắn mọi thứ một lần nữa.

⌈/{⍳⌊⍵*÷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 byte

→←½Ḋ

Hãy thử trực tuyến!

Giải trình

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

R , 45 33 byte

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

Hãy thử trực tuyến!

Nguyên:

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

Hãy thử trực tuyến!

Mã máy x86 32 bit (IA32): 18 16 byte

changelog: xử lý n=1trường hợp kiểm tra chính xác, lưu 2 byte và trả về EAX.

Đếm cho đến khi n/i <= i(tức là khi chúng ta đạt đến sqrt) và sử dụng ước số chính xác đầu tiên sau đó.

Phiên bản 64 bit này có thể gọi được từ C với quy ước gọi System V x86-64, như
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

Hãy thử trực tuyến! với một người gọi asm sử dụng byte đầu tiên của argv [1] làm số nguyên trực tiếp và sử dụng kết quả làm trạng thái thoát quy trình.

$ 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 byte

â f§U¬

Thử nó

Lưu 2 byte nhờ Oliver

Giải trình

           :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

Thạch , 5 byte

ọⱮ½TṪ

Hãy thử trực tuyến!

JavaScript ES7, 33 31 byte

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

Dùng thử trực tuyến

Người tuyết , 38 byte

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

Hãy thử trực tuyến!

((
  }        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
))

đc , 24

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

Hãy thử trực tuyến!

Giải trình:

?                         # 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 byte

-5 byte nhờ ý tưởng GCD của Sherlock

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

Hãy thử trực tuyến!

câu trả lời gốc

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

Hãy thử trực tuyến!

phân tích cú pháp

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

giải trình

• 1 + i.@<.@%: đưa ra phạm vi 1 .. floor(sqrt) .
• toàn bộ động từ (A) Btạo thành một hook, với phạm vi trên được truyền dưới dạng arg bên phải ]cho A và số ban đầu được truyền dưới dạng arg bên trái của nó [. Do đó ...
• ] | [ cung cấp phần còn lại của mỗi mục trong phạm vi được chia thành đối số ban đầu.
• và 0 = ] | [đưa ra các ước số không có phần còn lại.
• ] #~ ... sau đó lọc phạm vi, chỉ để lại những cái đó.
• và {:đưa ra mục cuối cùng trong danh sách, tức là mục lớn nhất.

Thạch , 5 byte

½ḍƇµṪ

Hãy thử trực tuyến!

Haskell , 36 byte

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

Hãy thử trực tuyến!

$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 byte

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

Forth (gforth) , 53 byte

Cách ngắn nhất dường như là sử dụng ngăn xếp dấu phẩy động và fsqrt, ngắn nhất tôi có thể nhận được mà không có nó là 62 byte bằng cách sử dụng /modvà kiểm tra xem thương số có lớn hơn ước số hay không.

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

Hãy thử trực tuyến!

Giải trình

1. Tính căn bậc hai
2. Bắt đầu từ căn bậc hai, giảm 1 cho đến khi chúng ta tìm thấy một yếu tố của số ban đầu

Giải thích mã

: 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 byte

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

Hãy thử trực tuyến!

Seq.findBack: Trả về phần tử cuối cùng mà hàm đã cho trả về True. Hàm trong trường hợp này kiểm tra xem một số có phải là một yếu tố của giá trị không.

Brain-Flak , 144 byte

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

Hãy thử trực tuyến!

Tôi không thực sự chắc chắn câu trả lời này là rất tốt. Tôi cảm thấy có thể có một cách hay để giải quyết nhiệm vụ này tuy nhiên tôi không đủ thông minh.

Giải trình

Tôi đã cố gắng thực hiện một cái nhìn bùng nổ về câu trả lời nhưng có rất nhiều phần chuyển động mà nó không được khai sáng cho lắm, vì vậy đây là một lời giải thích về những gì mã làm.

Điều quan trọng đầu tiên là điều này

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

$(x,y)$$x \geq y$ .

Phần tiếp theo là nhân, được thực hiện với sửa đổi từ wiki . Phép nhân này là đặc biệt vì nó bảo tồn các giá trị hiện có mà không phá hủy chúng. Nó như sau:

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

Vì vậy, chúng tôi đang nhân tất cả các cặp theo thứ tự. Đối với mỗi kết quả, chúng tôi kiểm tra nếu nó bằng với đầu vào. Nếu vậy, chúng tôi chấm dứt và trả lại các mục nhỏ hơn trong cặp.

Python 2 , 41 byte

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

Hãy thử trực tuyến!

Thạch , 6 byte

ÆDŒHḢṪ

Hãy thử trực tuyến!

Perl 5 -p , 26 byte

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

Hãy thử trực tuyến!

Rust, 71 70 byte

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

Phiên bản tiền xấu

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
}

Chỉnh sửa

• Lưu một byte với > 0hơn != 0. (Cảm ơn @CatWizard)

Japt , 8 byte

â w æ§Uq

Hãy thử trực tuyến!

Hình tam giác , 49 byte

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

Hãy thử trực tuyến!

Pyret , 93 byte

{(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)))}

Bạn có thể thử trực tuyến bằng cách sao chép nó vào trình soạn thảo Pyret trực tuyến !

Trên đây đánh giá một chức năng ẩn danh. Khi nó được áp dụng cho một số nguyên, nó sẽ trả về một kết quả theo đặc tả.

Thực ra , 7 byte

Dựa trên câu trả lời APL của tôi ở đây . Gợi ý chơi golf chào mừng! Hãy thử trực tuyến!

;√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.

Một cổng của câu trả lời Mathicala này .

Thạch , 11 byte

½ðḞ³÷Ċ³÷µÐL

Hãy thử trực tuyến!

Điều này (11 byte) cũng hoạt động và không phụ thuộc vào ³:

½Ḟ÷@Ċ÷@ʋƬµṪ

Thật không may ½Ḟ÷@Ċ÷@ʋÐL(10 byte) không hoạt động. Và rõ ràng Ƭvà ÐĿkhông hoàn toàn giống nhau (khi liên kết là dyadic)

$n$

• $i = \sqrt n$$a$ .
• Ở mỗi bước:
  • $i$$\lfloor i\rfloor$
  • $n\over i$$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$
• $i$$n \div \lceil \frac n {\lfloor i\rfloor} \rceil$

Java 8, 65 54 byte

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

Cổng 3 câu trả lời Python của @hunteke .

Hãy thử trực tuyến.

Câu trả lời cũ 65 byte:

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

Hãy thử trực tuyến.

Giải trình:

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`