Schreiben Sie einen Code, der bei einer positiven Zahl $x$ als Eingabe den größten positiven Teiler von kleiner oder gleich der Quadratwurzel von ausgibt .$x$$x$

Mit anderen Worten, finde das größte so, dass$n > 0$

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

^{(Exists größer als oder gleich , so daß mal ist )$m$$n$$m$$n$$x$}

Wenn die Eingabe beispielsweise $12$ die Teiler $1$ , $2$ , $3$ , $4$ , $6$ und $12$ . $1$ , $2$ und $3$ multiplizieren sich alle mit größeren Zahlen, um zu erhalten $12$, aber $3$ ist die größte, also geben wir $3$ .

Dies ist Codegolf, daher werden die Antworten in Bytes bewertet, wobei weniger Bytes als bessere Bewertung gelten.

Testfälle

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

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

Erläuterung

• l=x**.5//1→ Weisen Sie ldie größte Ganzzahl zu, die kleiner als die Quadratwurzel von istx
• while x%l:l-=1→ Während lsich nicht gleichmäßig teilt x, wird dekrementiert l.

Bearbeitungen

• Erwähnen Sie Python3, nicht Python2
• Verwenden Sie ...//1zwei Bytes zu speichern. (Dezimalzahlen sind in Ordnung! Danke @Rod)

MATL , 7 Bytes

Z\tn2/)

Probieren Sie es online!

Für diese Erklärung verwenden wir '12' als Beispieleingabe. Erläuterung:

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

Dies funktioniert aufgrund vieler glücklicher Zufälle.

1. MATL verwendet 1 Indexierung
2. Wenn wir mit einer Nicht-Ganzzahl indizieren (dies geschieht für jede perfekte Quadrateingabe), dann <n>)indizieren $\lceil n \rceil$

C (gcc) -lm , 35 Bytes

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

Probieren Sie es online!

05AB1E , 5 Bytes

Ñ2äнθ

Probieren Sie es online! oder als Testsuite

Erläuterung

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

Ich bin froh, dass ich eine Antwort in APL schreiben konnte, da ich es gerade erst gelernt habe. Vielen, vielen Dank an Adám für die Hilfe beim Golfen. Golfvorschläge sind sehr willkommen. Probieren Sie es online!

Weitere Informationen zu APL finden Sie unter The APL Orchard .

BEARBEITEN: -2 Bytes zur Behebung eines Problems mit meinem Code. Vielen Dank an H.PWiz für den Hinweis auf dieses Problem. -2 Bytes von alles wieder verkürzen.

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

Schale , 4 Bytes

→←½Ḋ

Probieren Sie es online!

Erläuterung

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

R , 45 33 Bytes

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

Probieren Sie es online!

Original:

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

Probieren Sie es online!

x86 32-Bit-Computercode (IA32): 18 bis 16 Byte

Changelog: Behandle den n=1Testfall korrekt, speichere 2 Bytes und kehre in EAX zurück.

Zählen Sie bis n/i <= i(dh bis zum Erreichen des sqrt) und verwenden Sie danach den ersten exakten Divisor.

Eine 64-Bit-Version davon kann mit der Aufrufkonvention x86-64 System V von C aus aufgerufen werden
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

Probieren Sie es online! mit einem asm-Aufrufer, der das erste Byte von argv [1] direkt als Ganzzahl verwendet und das Ergebnis als Prozess-Exit-Status verwendet.

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

â f§U¬

Versuch es

2 Bytes gespart dank Oliver

Erläuterung

           :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

Gelee , 5 Bytes

ọⱮ½TṪ

Probieren Sie es online!

JavaScript ES7, 33 31 Bytes

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

Probieren Sie es online aus

Schneemann , 38 Bytes

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

Probieren Sie es online!

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

Probieren Sie es online!

Erläuterung:

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

-5 Bytes dank Sherlocks GCD-Idee

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

Probieren Sie es online!

ursprüngliche Antwort

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

Probieren Sie es online!

analysiert

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

Erläuterung

• 1 + i.@<.@%:gibt den Bereich an 1 .. floor(sqrt).
• Das gesamte Verb (A) Bbildet einen Haken, wobei der obige Bereich als rechtes Argument ]an A und die ursprüngliche Zahl als linkes Argument übergeben wird [. Somit...
• ] | [ gibt den verbleibenden Teil eines jeden Artikels in dem Bereich an, der in das ursprüngliche Argument unterteilt ist.
• und 0 = ] | [gibt den Teilern keinen Rest.
• ] #~ ... filtert dann den Bereich und lässt nur diese übrig.
• und {:gibt das letzte Element in der Liste an, dh das größte.

Gelee , 5 Bytes

½ḍƇµṪ

Probieren Sie es online!

Haskell , 36 Bytes

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

Probieren Sie es online!

Nun, das ist meine Antwort auf diese Herausforderung. Dies verwendet ein bestimmtes Listenverständnis, um die Antwort zu finden. In unserem Listenverständnis wählen wir aus$y$von der unendlichen Liste [1..], die die positiven ganzen Zahlen ist, und wir holen$z$aus der Liste [1..y]. Das bedeutet, dass$(y,z)$ sind alle geordneten Paare so, dass $y \geq z$.

Wir wählen dann nur die Paare so aus, dass $y\cdot z=x$Dies bedeutet, dass wir die Liste aller Paare von Zahlen erstellen, die sich multiplizieren $x$. Seitdem basiert unser Verständnis zunächst auf$y$ und dann $z$ Dies bedeutet, dass unsere Paare in aufsteigender Reihenfolge von $y$, oder sinnvoller in absteigender Reihenfolge von $z$.

Also, um das Größte zu bekommen $z$ wir nehmen die $z$Zugehörigkeit zum ersten Element. Das ist unser Ergebnis.

QBasic (4.5), 52 Bytes

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

Viertens (gviertens) , 53 Bytes

Der kürzeste Weg scheint die Verwendung des Gleitkommastapels zu sein, und fsqrtder kürzeste, den ich ohne diesen Stapel bekommen könnte, war die Verwendung von 62 Bytes /modund die Überprüfung, ob der Quotient größer als der Divisor war.

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

Probieren Sie es online!

Erläuterung

1. Berechnen Sie die Quadratwurzel
2. Ab der Quadratwurzel um 1 verringern, bis wir einen Faktor der ursprünglichen Zahl finden

Code-Erklärung

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

Probieren Sie es online!

Seq.findBack: Gibt das letzte Element zurück, für das die angegebene Funktion zurückgibt True. Die Funktion prüft in diesem Fall, ob eine Zahl ein Wertfaktor ist.

Brain-Flak , 144 Bytes

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

Probieren Sie es online!

Ich bin mir nicht sicher, ob diese Antwort wirklich gut ist. Ich habe das Gefühl, dass es einen guten Weg gibt, diese Aufgabe zu lösen, aber ich bin einfach nicht schlau genug.

Erläuterung

Ich habe versucht, eine Explosionsansicht der Antwort zu erstellen, aber es gibt so viele bewegliche Teile, dass es nicht sehr aufschlussreich war. Hier finden Sie eine Erläuterung der Funktionsweise des Codes.

Der erste wichtige Punkt ist dies

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

Dabei werden die beiden Zahlen oben auf dem Stapel abgelegt. Wenn sie ungleich sind, wird die zweite Zahl inkrementiert. Wenn sie gleich sind, wird die erste Zahl inkrementiert und die zweite durch Null ersetzt. Wenn wir diesen Code ein paar Mal wiederholen, erhalten wir alle Paare$(x,y)$ so dass $x \geq y$.

Der nächste Teil ist die Multiplikation mit Änderungen aus dem Wiki . Diese Multiplikation ist besonders, weil sie die vorhandenen Werte beibehält, ohne sie zu zerstören. Es geht so:

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

Wir multiplizieren also alle diese geordneten Paare. Für jedes Ergebnis prüfen wir, ob es der Eingabe entspricht. In diesem Fall kündigen wir und senden den kleineren Artikel des Paares zurück.

Python 2 , 41 Bytes

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

Probieren Sie es online!

Gelee , 6 Bytes

ÆDŒHḢṪ

Probieren Sie es online!

Perl 5 -p , 26 Bytes

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

Probieren Sie es 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}

Vor-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
}

Bearbeitungen

• Speichern Sie ein Byte mit > 0über != 0. (Danke an @CatWizard)

Japt , 8 Bytes

â w æ§Uq

Probieren Sie es online!

Dreieckigkeit , 49 Bytes

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

Probieren Sie es 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)))}

Sie können dies online versuchen, indem Sie es in den Online-Pyret-Editor kopieren !

Das obige wird zu einer anonymen Funktion ausgewertet. Wenn es auf eine Ganzzahl angewendet wird, gibt es ein Ergebnis gemäß der Spezifikation zurück.

Eigentlich 7 Bytes

Basierend auf meiner APL-Antwort hier . Golfvorschläge willkommen! Probieren Sie es 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.

Ein Port dieser Mathematica-Antwort .

Jelly , 11 Bytes

½ðḞ³÷Ċ³÷µÐL

Probieren Sie es online!

Dies (11 Bytes) funktioniert auch und ist nicht abhängig von ³:

½Ḟ÷@Ċ÷@ʋƬµṪ

Leider ½Ḟ÷@Ċ÷@ʋÐL(10 Bytes) funktioniert nicht. Und anscheinend Ƭund ÐĿist nicht genau das gleiche (wenn der Link dyadisch ist)

Methode: (let $n$ die Eingabe sein)

• Beginnen Sie mit einer oberen Schranke $i = \sqrt n$ der Antwort $a$.
• Bei jedem Schritt:
  • Ob $i$ ist keine ganze Zahl, dann kann die Obergrenze gesetzt werden $\lfloor i\rfloor$ (weil das Ergebnis eine ganze Zahl sein muss)
  • Ob $n\over i$ ist also keine ganze Zahl $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$.
• Also ersetzen wir immer wieder $i$ mit $n \div \lceil \frac n {\lfloor i\rfloor} \rceil$ bis es behoben ist.

Java 8, 65 54 Bytes

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

Port von @huntekes Python 3 Antwort .

Probieren Sie es online aus.

Alte 65-Byte-Antwort:

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

Probieren Sie es online aus.

Erläuterung:

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`