/vichan/ - Śmieszne obrazki

kurde jakieś duże te numerki

>iksy dupiksy na co to komu

skurwysyny. Macie tutaj funkcje, kurwa, ef od iks w tym punkcie, kurwa, a tu w tym punkcie macie kurwa skurwysyny, polskie śmiecie jebane, ef iks dodać kurwa delta iks, nie? Dla kurwa Eweliny i jej chłopaka, chuja jebanego, polskich zwierząt

Polibudziarz hiere zdana analiza matematyczna, algebra liniowa, kurwa całki, zespolone, geo analityczna, rachunek różniczkowi i tak chuja wiem xD

Największe to takie wyliczyłem, ale na pewno do D=1000 to są jeszcze większe:

16266196520² - 199*1153080099² = 1

Niech się tam trochę klocek pogrzeje, może nie będę musiał optymalizować algorytmu ;3

>>163313

Uważaj na dokładność po przecinku Anon

>>163323

Nie lecę na floatach, ale w sumie założyłem, że y>0, a to może być błędne założenie.

>>163324

W sumie nie jest błędne dla x>1. Niepotrzebnie zatrzymałem liczenie ehhh.

Odpaliłem na lepszym sprzęcie i liczy, ale najlepszy wynik do tej pory:

695359189925² - 856*23766887823² = 1

Moje rozwiązanie:

[spoiler]

import math
import decimal

decimal.getcontext().prec = 75


def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)


def lcm(a, b):
    return abs(a * b) // gcd(a, b)


class Fraction():
    def __init__(self, numerator, denominator):
        self.numerator = numerator
        self.denominator = denominator

    def __add__(self, fraction):
        result = Fraction(0, 0)
        if self.denominator != fraction.denominator:
            result.denominator = lcm(self.denominator, fraction.denominator)
            numerator = (self.numerator *
                         (result.denominator // self.denominator))
            other_numerator = fraction.numerator * \
                (result.denominator // fraction.denominator)
            result.numerator = numerator + other_numerator
        else:
            result.numerator = self.numerator + fraction.numerator
            result.denominator = self.denominator
        return result

    def reverse(self):
        return Fraction(self.denominator, self.numerator)

    def __repr__(self):
        return '{}/{}'.format(self.numerator, self.denominator)


def are_solutions(x, y, d):
    return x**2 - d * y**2 == 1


def calculate_fraction_convergent(period):
    first_value = Fraction(period[0], 1)
    fraction = Fraction(1, period[1])
    for i in range(2, len(period)):
        fraction = (Fraction(period[i], 1) + fraction).reverse()
    return first_value + fraction


def main():
    serach_range = filter(lambda x: not(
        math.sqrt(x).is_integer()), range(2, 1001))
    max_x = -1
    answer = 0
    for d in serach_range:
        x = 0
        y = 0
        starting_value = decimal.Decimal(d).sqrt()
        period = [math.floor(starting_value)]
        n = 1 / (starting_value - math.floor(starting_value))
        while not are_solutions(x, y, d):
            a = math.floor(n)
            period.append(a)
            n = 1 / (n - math.floor(n))
            solutions = calculate_fraction_convergent(period)
            x = solutions.numerator
            y = solutions.denominator
        print("x={}, y={}, d={}".format(x, y, d))
        if x > max_x:
            max_x = x
            answer = d
    print(answer)


if __name__ == '__main__':
    main()

[/spoiler]

Liczy do d=1000. zmieniajac precyzje, mozna policzyc wyzej.

Moje takie, ale czy doliczy do końca, to nie wiem xD

#include <unistd.h>
#include <stdlib.h>
#include <gmp.h>

int main(int argc, char **argv) {
  unsigned int d;
  mpz_t d_, max;
  mpz_init(d_);
  mpz_init_set_ui(max, 0);
  
  int begin = 2, inc = 1, fin = 1000;
  if (argc > 1) begin = atoi(argv[1]);
  if (argc > 2)   inc = atoi(argv[2]);
  if (argc > 3)   fin = atoi(argv[3]);

  unsigned long inc_y = 1;
  unsigned long count_y = 16777216; // 2**24
  
  unsigned long iter_y = 0;
  
  int done_x[1001] = {0};
  
  while (1) {
    unsigned long init_y = inc_y + iter_y * count_y;
    
    int tested = 0;
    
    for (d = begin; d < fin; d+=inc) {
      if (done_x[d]) continue;
      mpz_set_ui(d_, d);
      if (mpz_perfect_square_p(d_)) { done_x[d] = 1; continue; };
      tested += 1;

      mpz_t x, dysq, xsq;
      mpz_inits(x, dysq, xsq, NULL);
      unsigned long y = init_y, iter = 0;

      while (1) {
        mpz_mul_ui(dysq, d_, y);
        mpz_mul_ui(dysq, dysq, y);
        mpz_add_ui(xsq, dysq, 1);        
        if (mpz_perfect_square_p(xsq)) break;
        if (iter > count_y) goto skip;

       	y += 1;
        iter += 1;
      }

      mpz_sqrt(x, xsq);

      done_x[d] = 2;

      if (mpz_cmp (max, x) < 0) {
        mpz_set(max, x);
        gmp_printf("New best: %Zd² - %d*%ld² = 1\n", x, d, y);
      }

      skip: {}
    }
    
    gmp_printf("Finished iteration %d : tested %d numbers : remaining: ", iter_y, tested);
    for (d = begin; d < fin; d+=inc) {
      if (!done_x[d]) gmp_printf("%d,", d);
    }
    gmp_printf("\n");
    if (tested == 0) break;
    iter_y += 1;
  }
}

gcc -O3 -Wall 66.c -o 66

Odpalam: ./66 (2+numer wątka liczone od 0) (ilość wątków)

>>163333

To znaczy, oczywiście:

gcc -O3 -Wall -lgmp 66.c -o 66

>>163331

ja pierdole kurwa….

niech mnie chuj

Kurwa…. powiedz. ty jesteś szcześliwy w życiu?

>>163369

? To nie jest nic trudnego, wystarczyło dojść do tego, że to jest równanie Pella, a potem zaimplementować rozwiązywarkę

dawjacie to: https://projecteuler.net/problem=64

>>163404

wróć do 4chan i umieść tam kucyki, dziwny skurwielu

>>163404

https://youtu.be/M64HUIJFTZM

>>163450

esteś upośledzony i byłeś tak bezużyteczny jako dziecko, że nikt się nie przejmował, kiedy byłeś molestowany seksualnie

XD

>>163497

byłeś wykorzystywany seksualnie jako dziecko