Dado um número inteiro positivo que não é um quadrado, encontre a solução fundamental da equação de Pell associada$n$$(x,y)$

Detalhes

• O fundamental é um par de números inteiros satisfazendo a equação em que é mínimo e positivo. (Sempre existe a solução trivial que não é contada.)$(x,y)$$x,y$$x$$(x,y)=(1,0)$
• Você pode assumir que não é um quadrado.$n$

Exemplos

 n           x    y
 1           -    -
 2           3    2
 3           2    1
 4           -    -
 5           9    4
 6           5    2
 7           8    3
 8           3    1
 9           -    -
10          19    6
11          10    3
12           7    2
13         649    180
14          15    4
15           4    1
16           -    -
17          33    8
18          17    4
19         170    39
20           9    2
21          55    12
22         197    42
23          24    5
24           5    1
25           -    -
26          51    10
27          26    5
28         127    24
29        9801    1820
30          11    2
31        1520    273
32          17    3
33          23    4
34          35    6
35           6    1
36           -    -
37          73    12
38          37    6
39          25    4
40          19    3
41        2049    320
42          13    2
43        3482    531
44         199    30
45         161    24
46       24335    3588
47          48    7
48           7    1
49           -    -
50          99    14
51          50    7
52         649    90
53       66249    9100
54         485    66
55          89    12
56          15    2
57         151    20
58       19603    2574
59         530    69
60          31    4
61  1766319049    226153980
62          63    8
63           8    1
64           -    -
65         129    16
66          65    8
67       48842    5967
68          33    4
69        7775    936
70         251    30
71        3480    413
72          17    2
73     2281249    267000
74        3699    430
75          26    3
76       57799    6630
77         351    40
78          53    6
79          80    9
80           9    1
81           -    -
82         163    18
83          82    9
84          55    6
85      285769    30996
86       10405    1122
87          28    3
88         197    21
89      500001    53000
90          19    2
91        1574    165
92        1151    120
93       12151    1260
94     2143295    221064
95          39    4
96          49    5
97    62809633    6377352
98          99    10
99          10    1

Sequências OEIS relevantes: A002350 A002349 A033313 A033317

Piet , 612 codéis

Toma n da entrada padrão. Emite y e x , separados por espaço.

Codel size 1:

Codel tamanho 4, para facilitar a visualização:

Explicação

Confira este rastreamento NPiet , que mostra o programa calculando a solução para um valor de entrada 99.

Não tenho certeza se alguma vez ouvi falar da equação de Pell antes desse desafio, por isso recebi o seguinte na Wikipedia; especificamente, essas seções de três artigos:

• Equação de Pell § Solução fundamental por frações continuadas
• Métodos de computação de raízes quadradas § Expansão contínua da fração
• Fração continuada § Frações contínuas infinitas e convergentes

Basicamente, o que fazemos é o seguinte:

1. Obtenha da entrada padrão.$n$
2. Encontre incrementando um contador até que seu quadrado exceda , em seguida, diminua-o uma vez. (Este é o primeiro loop que você pode ver no rastreamento, no canto superior esquerdo.)$\lfloor\sqrt n\rfloor$$n$
3. Defina-se algumas variáveis para calcular e a partir da fracção de continuação .$x$$y$$\sqrt n$
4. Verifique se e caber equação de Pell ainda. Se o fizerem, produza os valores (este é o ramo descendente cerca de 2/3 do caminho) e saia (correndo para o bloco vermelho na extrema esquerda).$x$$y$
5. Caso contrário, atualize iterativamente as variáveis ​​e volte para a etapa 4. (Este é o loop amplo para a direita, de volta para baixo e voltando a entrar no meio do caminho.)

Sinceramente, não tenho idéia se uma abordagem de força bruta seria mais curta, e não vou tentar! Ok, então eu tentei.

Piet , 184 codéis

Essa é a alternativa de força bruta que eu disse (na minha outra resposta ) que não queria escrever. Demora mais de 2 minutos para calcular a solução para n = 13. Eu realmente não quero experimentá-lo em n = 29 ... mas ele faz check-out para cada n até 20, por isso estou confiante de que está correto.

Assim como a outra resposta, isso leva n da entrada padrão e gera y e x , separados por espaço.

Codel size 1:

Codel tamanho 4, para facilitar a visualização:

Explicação

Aqui está o rastreamento NPiet para um valor de entrada 5.

Esta é a força bruta mais brutal, repetindo tanto quanto . Outras soluções podem iterar sobre e calcular , mas são fracos .$x$$y$$x$$y=\sqrt{\frac{x^2-1}{n}}$

Começando com e , isso verifica se e já resolveram a equação. Se tiver (o garfo na parte inferior, próximo à direita), ele gera os valores e sai.$x=2$$y=1$$x$$y$

Caso contrário, ele continua à esquerda, onde é incrementado e comparado com . (Depois, há algumas mudanças de direção para seguir o caminho em zig-zag.)$y$$x$

Esta última comparação é onde o caminho se divide em torno do meio esquerdo. Se eles são iguais, é incrementado e é retornado para 1. E voltamos a verificar se ainda é uma solução.$x$$y$

Ainda tenho algum espaço em branco disponível, então talvez eu veja se consigo incorporar esse cálculo de raiz quadrada sem ampliar o programa.

Braquilog , 16 bytes

;1↔;Ċz×ᵐ-1∧Ċ√ᵐℕᵐ

Experimente online!

Explicação

;1↔                Take the list [1, Input]
   ;Ċz             Zip it with a couple of two unknown variables: [[1,I],[Input,J]]
      ×ᵐ           Map multiply: [I, Input×J]
        -1         I - Input×J must be equal to 1
          ∧        (and)
           Ċ√ᵐ     We are looking for the square roots of these two unknown variables
              ℕᵐ   And they must be natural numbers
                   (implicit attempt to find values that match those constraints)

Pari / GP , 34 bytes

O PARI / GP quase possui um recurso interno para isso: quadunitfornece a unidade fundamental do campo quadrático , onde é o discriminante do campo. Em outras palavras, resolve a equação de Pell . Então eu tenho que pegar o quadrado quando sua norma é .$\mathbb{Q}(\sqrt{D})$$D$x2-n⋅y2=±1-1quadunit(4*n)$x^2 - n \cdot y^2 = \pm 1$$-1$

Não sei qual algoritmo ele usa, mas funciona mesmo quando não é quadrado.$n$

As respostas são fornecidas no formulário x + y*w, onde wdenota .$\sqrt{n}$

n->(a=quadunit(4*n))*a^(norm(a)<0)

Experimente online!

Wolfram Language (Mathematica) , 46 bytes

FindInstance[x^2-y^2#==1&&x>1,{x,y},Integers]&

Experimente online!

05AB1E , 17 16 14 bytes

Guardou um byte graças a Kevin Cruijssen .
Saídas[y, x]

∞.Δn*>t©1%_}®‚

Experimente online!

Explicação

∞                 # from the infinite list of numbers [1 ...]
 .Δ        }      # find the first number that returns true under
   n              # square
    *             # multiply with input
     >            # increment
      t©          # sqrt (and save to register as potential x)
        1%        # modulus 1
          _       # logical negation
            ®‚    # pair result (y) with register (x)

Java 8, 74 73 72 bytes

n->{int x=1;var y=.1;for(;y%1>0;)y=Math.sqrt(-x*~++x/n);return x+" "+y;}

-1 byte graças a @Arnauld .
-1 byte graças a @ OlivierGrégoire .

Experimente online.

Explicação:

n->{                 // Method with double parameter and string return-type
  int x=1;           //  Integer `x`, starting at 1
  var y=.1;          //  Double `y`, starting at 0.1
  for(;y%1>0;)       //  Loop as long as `y` contains decimal digits:
    y=               //   Set `y` to:
      Math.sqrt(     //    The square-root of:
        -x*          //     Negative `x`, multiplied by
           ~++x      //     `(-x-2)` (or `-(x+1)-1)` to be exact)
                     //     (because we increase `x` by 1 first with `++x`)
               /n);  //     Divided by the input
  return x+" "+y;}   //  After the loop, return `x` and `y` with space-delimiter as result

R, 66 56 54 53 52 47 45 bytes

um programa completo

n=scan();while((x=(1+n*T^2)^.5)%%1)T=T+1;x;+T

-1 -2 graças a @Giuseppe

-7 graças a @ Giuseppe e @Robin Ryder -2 @JAD

Geléia , 40 bytes

½©%1İ$<®‘¤$п¹;Ḋ$LḂ$?Ḟṭ@ṫ-ṚZæ.ʋ¥ƒØ.,U¤-ị

Experimente online!

Uma resposta alternativa da Jelly, menos eficiente, mas mais eficiente quando algoritmos x e y são grandes. Ele encontra os convergentes da fração contínua regular que se aproxima da raiz quadrada de n e, em seguida, verifica qual resolve a equação de Pell. Agora encontra corretamente o período da fração contínua regular.

Graças a @TimPederick, também implementei uma solução baseada em número inteiro que deve lidar com qualquer número:

Geléia , 68 bytes

U×_ƭ/;²®_$÷2ị$}ʋ¥µ;+®Æ½W¤:/$$
¹©Æ½Ø.;ÇƬṪ€F¹;Ḋ$LḂ$?ṭ@ṫ-ṚZæ.ʋ¥ƒØ.,U¤-ị

Experimente online!

Por exemplo, a solução para 1234567890 possui dígitos de 1936 e 1932 para o numerador e o denominador, respectivamente.

JavaScript (ES7), 47 bytes

n=>(g=x=>(y=((x*x-1)/n)**.5)%1?g(x+1):[x,y])(2)

Experimente online!

Abaixo está uma versão alternativa de 49 bytes, que monitora diretamente em vez de esquadrinhar a cada iteração:$x²-1$$x$

n=>[(g=x=>(y=(x/n)**.5)%1?1+g(x+=k+=2):2)(k=3),y]

Experimente online!

Ou podemos seguir o caminho não recursivo por 50 bytes :

n=>eval('for(x=1;(y=((++x*x-1)/n)**.5)%1;);[x,y]')

Experimente online!

TI-BASIC,  44  42 41 bytes

Ans→N:"√(N⁻¹(X²-1→Y₁:1→X:Repeat not(fPart(Ans:X+1→X:Y₁:End:{X,Ans

Entrada é . Saída é uma lista cujos valores correspondem a .$n$
$(x,y)$

Usa a equação para para calcular a solução fundamental. O par atual para essa equação é uma solução fundamental se .$y=\sqrt{\frac{x^2-1}{n}}$$x\ge2$
$(x,y)$$y\bmod1=0$

Exemplos:

6
               6
prgmCDGF12
           {5 2}
10
              10
prgmCDGF12
          {19 6}
13
              13
prgmCDGF12
       {649 180}

Explicação:

Ans→N:"√(N⁻¹(X²+1→Y₁:1→X:Repeat not(fPart(Ans:X+1→X:Y₁:End:{X,Ans  ;full logic

Ans→N                                                              ;store the input in "N"
      "√(N⁻¹(X²+1→Y₁                                               ;store the aforementioned
                                                                   ; equation into the first
                                                                   ; function variable
                     1→X                                           ;store 1 in "X"
                         Repeat not(fPart(Ans          End         ;loop until "Ans" is
                                                                   ; an integer
                                              X+1→X                ;increment "X" by 1
                                                    Y₁             ;evaluate the function
                                                                   ; stored in this variable
                                                                   ; at "X" and leave the
                                                                   ; result in "Ans"
                                                           {X,Ans  ;create a list whose
                                                                   ; values contain "X" and
                                                                   ; "Ans" and leave it in
                                                                   ; "Ans"
                                                                   ;implicitly print "Ans"

Nota: TI-BASIC é um idioma tokenizado. Contagem de caracteres não é igual à contagem de bytes.

MATL , 17 bytes

`@:Ut!G*-!1=&fts~

Experimente online!

Explicação

O código continua aumentando um contador k = 1, 2, 3, ... Para cada k , as soluções x , y com 1 ≤ x ≤ k , 1 ≤ y ≤ k são pesquisadas. O processo quando alguma solução for encontrada.

Esse procedimento é garantido para encontrar apenas uma solução, que é precisamente a fundamental. Para ver o porquê, observe que

1. Qualquer solução x > 0, y > 0 para n > 1 satisfaz x > y .
2. Se x , y é uma solução ex ', y ' é uma solução diferente, então necessariamente x ≠ x ' e y ≠ y '.

Como conseqüência de 1 e 2,

• Quando o procedimento para em um determinado k , existe apenas uma solução para esse k , porque se houvesse duas soluções, uma delas seria encontrada anteriormente e o processo teria parado com um k menor .
• Essa solução é fundamental, porque, novamente, se houvesse uma solução com x menor, ela teria sido encontrada anteriormente.

`       % Do...while
  @:U   %   Push row vector [1^2, 2^2, ..., k^2] where k is the iteration index
  t!    %   Duplicate and transpose. Gives the column vector [1^2; 2^2; ...; k^2]
  G*    %   Multiply by input n, element-wise. Gives [n*1^2; n*2^2; ...; n*k^2]
  -     %   Subtract with broadcast. Gives a square matrix of size n
  !     %   Transpose, so that x corresponds to row index and y to column index
  1=&f  %   Push row and column indices of all entries that equal 1. There can
        %   only be (a) zero such entries, in which case the results are [], [],
        %   or (b) one such entry, in which case the results are the solution x, y
  ts~   %   Duplicate, sum, negate. This gives 1 in case (a) or 0 in case (b)
        % End (implicit). Proceed with next iteration if top of the stack is true;
        % that is, if no solution was found.
        % Display (implicit). The stack contains copies of [], and x, y on top.
        % The empty array [] is not displayed

Python 2 , 49 bytes

a=input()**.5
x=2
while x%a*x>1:x+=1
print x,x//a

Experimente online!

Encontra xcomo o menor número acima de 1 em que x % sqrt(n) <= 1/x. Então, encontra yde xcomo y = floor(x / sqrt(n)).

Haskell , 46 bytes

Uma busca direta por força bruta. Isso faz uso do fato de que uma solução fundamental satisfaz deve ter .$(x,y)$$x^2 - ny^2 = 1$$y \leq x$

f n=[(x,y)|x<-[1..],y<-[1..x],x^2-n*y^2==1]!!0

Experimente online!

C # (compilador interativo do Visual C #), 70 69 bytes

n=>{int x=1;var y=.1;for(;y%1>0;)y=Math.Sqrt(-x*~++x/n);return(x,y);}

Porta da minha resposta Java 8 , mas gera uma tupla em vez de uma string para salvar bytes.

Experimente online.

Gelatina , 15 bytes

‘ɼ²×³‘½µ⁺%1$¿;®

Experimente online!

Um programa completo que usa um único argumento ne retorna uma tupla de x, y.

Casca , 12 bytes

ḟΛ¤ȯ=→*⁰□π2N

Experimente online!

Explicação

ḟΛ¤ȯ=→*⁰□π2N  Input is n, accessed through ⁰.
           N  Natural numbers: [1,2,3,4,..
         π2   2-tuples, ordered by sum: [[1,1],[1,2],[2,1],[1,3],[2,2],..
ḟ             Find the first that satisfies this:
 Λ             All adjacent pairs x,y satisfy this:
  ¤     □       Square both: x²,y²
   ȯ  *⁰        Multiply second number by n: x²,ny²
     →          Increment second number: x²,ny²+1
    =           These are equal.

MathGolf , 12 bytes

ökî²*)_°▼Þ√î

Experimente online!

Estou jogando uma Ave Maria quando se trata da formatação de saída. Se não for permitido, tenho uma solução com 1 byte a mais. O formato de saída é x.0yonde .0está o separador entre os dois números.

Explicação

ö       ▼      do-while-true with popping
 k             read integer from input
  î²           index of current loop (1-based) squared
    *          multiply the two
     )         increment (gives the potential x candidate
      _        duplicate TOS
       °       is perfect square
         Þ     discard everything but TOS
          √    square root
           î   index of previous loop (1-based)

Eu me inspirei na resposta 05AB1E de Emigna, mas consegui encontrar algumas melhorias. Se o separador escolhido não for permitido, adicione um espaço antes do último byte para uma contagem de 13 bytes.

APL (NARS), 906 bytes

r←sqrti w;i;c;m
m←⎕ct⋄⎕ct←0⋄r←1⋄→3×⍳w≤3⋄r←2⋄→3×⍳w≤8⋄r←w÷2⋄c←0
i←⌊(2×r)÷⍨w+r×r⋄→3×⍳1≠×r-i⋄r←i⋄c+←1⋄→2×⍳c<900⋄r←⍬
⎕ct←m

r←pell w;a0;a;p;q2;p2;t;q;P;P1;Q;c;m
   r←⍬⋄→0×⍳w≤0⋄a0←a←sqrti w⋄→0×⍳a≡⍬⋄m←⎕ct⋄⎕ct←0⋄Q←p←1⋄c←P←P1←q2←p2←0⋄q←÷a
L: t←p2+a×p⋄p2←p⋄p←t
   t←q2+a×q
   :if c≠0⋄q2←q⋄:endif
   q←t           
   P←(a×Q)-P
   →Z×⍳Q=0⋄Q←Q÷⍨w-P×P
   →Z×⍳Q=0⋄a←⌊Q÷⍨a0+P
   c+←1⋄→L×⍳(1≠Qׯ1*c)∧c<10000
   r←p,q
   :if c=10000⋄r←⍬⋄:endif
Z: ⎕ct←m

Acima, existem 2 funções sqrti função que iria encontrar a função de raiz e Pell quadrado chão voltaria Zilde para erro, e baseia-se ler a página http://mathworld.wolfram.com/PellEquation.html seria usar a algo para saber a sqrt de um número trhu continue a fração (mesmo se eu usar um algo para saber sqrt usando o método newton) e pare quando encontrar p e q de modo que

 p^2-w*q^2=1=((-1)^c)*Qnext

Teste:

  ⎕fmt pell 1x
┌0─┐
│ 0│
└~─┘
  ⎕fmt pell 2x
┌2───┐
│ 3 2│
└~───┘
  ⎕fmt pell 3x
┌2───┐
│ 2 1│
└~───┘
  ⎕fmt pell 5x
┌2───┐
│ 9 4│
└~───┘
  ⎕fmt pell 61x
┌2────────────────────┐
│ 1766319049 226153980│
└~────────────────────┘
  ⎕fmt pell 4x
┌0─┐
│ 0│
└~─┘
  ⎕fmt pell 7373x
┌2───────────────────────────────────────────────────────────┐
│ 146386147086753607603444659849 1704817376311393106805466060│
└~───────────────────────────────────────────────────────────┘
  ⎕fmt pell 1000000000000000000000000000002x
┌2────────────────────────────────────────────────┐
│ 1000000000000000000000000000001 1000000000000000│
└~────────────────────────────────────────────────┘

Existe um limite para ciclos no loop na função sqrti e um limite para ciclos no loop na função Pell, ambos para o número possível de casos são muito grandes ou algo não converge ... (não sei se o sqrti convergem todas as entradas possíveis e a mesma função Pell também)

Groovy , 53 bytes

n->x=1;for(y=0.1d;y%1>0;)y=((++x*x-1)/n)**0.5;x+" "+y

Experimente online!

Respostas Java e C # do porto de Kevin Cruijssen

Pitão, 15 bytes

fsIJ@ct*TTQ2 2J

Experimente online aqui . A saída é xentão yseparada por uma nova linha.

Wolfram Language (Mathematica) , 41 bytes

{1//.y_/;!NumberQ[x=√(y^2#+1)]:>y+1,x}&

√é o caractere Unicode de 3 bytes # 221A. Emite a solução na ordem (y, x) em vez de (x, y). Como de costume com o imperfeito //.e suas iterações limitadas, funciona apenas em entradas em que o valor real de yé no máximo 65538.

Experimente online!

> <> , 45 bytes

11v
+$\~:1
:}/!?:-1v?=1-*}:{*:@:{*:
$  naon;>

Experimente online!

Algoritmo de força bruta, pesquisando de x=2cima para baixo , com y=x-1e diminuindo em cada loop, incrementando xquando yatingir 0. A saída é xseguida por y, separada por uma nova linha.

C # (compilador interativo do Visual C #) , 69 bytes

n=>{for(int x=2,y;;x++)for(y=0;y<=x;y++)if(x*x-y*y*n==1)return(x,y);}

Experimente online!

Python 3 , 75 bytes

lambda i:next((x,y)for x in range(2,i**i)for y in range(x)if~-x**2==i*y**2)

Experimente online!

Explicação

Força bruta. Usando como um limite superior de pesquisa, que está bem abaixo do limite superior definido da solução fundamental da equação de Pell

Esse código também seria executado no Python 2. No entanto, a função range () no Python 2 cria uma lista em vez de um gerador como no Python 3 e, portanto, é imensamente ineficiente.

Com tempo e memória inifinte, pode-se usar uma compreensão de lista em vez do iterador e salvar 3 bytes da seguinte forma:

Python 3 , 72 bytes

lambda i:[(x,y)for x in range(i**i)for y in range(x)if~-x**2==i*y**2][1]

Experimente online!

Python 2 , 64 bytes

f=lambda n,x=2,y=1:x*x-n*y*y-1and f(n,x+(x==y),y*(y<x)+1)or(x,y)

Experimente online!

Retorna (x, y).