/vichan/ - Śmieszne obrazki

Siema OPie

Nie znam Closure, zrobiłem w pajtonie.

Zmierzmy penisa - u mnie rozwiązuje w 0.364257 s.

from time import time

funkcje = {'t' : (lambda n:n*(n+1)/2), 'p' : (lambda n:n*(3*n-1)/2), 'h' : (lambda n:n*(2*n-1)) }
wyniki = {'t'  : [285, 40755], 'p' : [165, 40755],  'h' : [143, 40755]}

def szukaj():
	i = max([a[1] for a in wyniki.values()])+1
	t1 = time()
	while True:
		for funkcja, xy in wyniki.items():
			if xy[1] < i:
				wyniki[funkcja][0] +=1
				wyniki[funkcja][1] = funkcje[funkcja](wyniki[funkcja][0])
		i = max([a[1] for a in wyniki.values()])
		if not [a for a in wyniki.values() if a[1] != i]: 
			print('Znaleziono rozwiazanie ({} s.):'.format(round(time()-t1,6)))
			for funkcja, xy in wyniki.items():
				print('{}({}) = {}'.format(funkcja,xy[0],xy[1]))
			break

>>138096

można spytać skąd wziąłeś to

>(1+math.sqrt(1+24*pn))/6

?

>>137435

using System;
using System.Diagnostics;

namespace euler {
    class Problem45 {

        public static void Main(string[] args) {                        
            new Problem45().BruteForce();
        }
                
        public void BruteForce() {
            Stopwatch clock = Stopwatch.StartNew();

            long result = 0;
            int i = 143;

            while (true) {
                i++;
                result = i * (2 * i - 1);

                if (isPentagonal(result)) {
                    break;
                }                    
            }
            
            clock.Stop();
            Console.WriteLine("The next triagonal, pentagonal and hexagonal number is {0}", result);
            Console.WriteLine("Solution took {0} ms", clock.ElapsedMilliseconds);
        }


        private bool isPentagonal(long number) {
            double penTest = (Math.Sqrt(1+24*number) + 1.0) / 6.0;
            return penTest == ((int)penTest);
        }
    }
}

Anony robili problem 46?

Próbuje w pythonie rekurencją ale szybko natrafiłem na

>RecursionError: maximum recursion depth exceeded while calling a Python object

xD

import sympy

class p46():
	"""
	It was proposed by Christian Goldbach that every odd composite number can be written as the sum of a prime and twice a square.

	9 = 7 + 2×1^2
	15 = 7 + 2×2^2
	21 = 3 + 2×3^2
	25 = 7 + 2×3^2
	27 = 19 + 2×2^2
	33 = 31 + 2×1^2

	It turns out that the conjecture was false.

	What is the smallest odd composite that cannot be written as the sum of a prime and twice a square?
	"""
	def kwadratx2(self, x): return 2 * pow(x,2)
	def oblicz(self, n, prime, i=1):
		kw2x = self.kwadratx2(i)
		if prime + kw2x == n: return [prime, i]
		elif prime + kw2x < n: return self.oblicz(n,prime,i+1)
		elif prime + kw2x > n: return self.oblicz(n, sympy.prevprime(prime))
	def start(self):
		n = 2
		while True:
			if not sympy.primetest.isprime(n) and n % 2 != 0:
				print(str(n), self.oblicz(n, sympy.prevprime(n)))
			n += 1

>>138301

https://docs.python.org/3/library/sys.html#sys.setrecursionlimit

Python ma wbudowany operator na potęgowanie jak wklepiesz x**y to Ci wyskoczy x do y.

Ja to tak rozwiązałem

#!/usr/bin/python3
import math
import sys
sys.path.append("project_euler")
from sieve_prime import sieve_primes

def main():
    primes = sorted(list(sieve_primes(10**4)))
    primes_max = max(primes)
    for odd_composite_number in odd_composite_number_generator(primes):
        if odd_composite_number > primes_max:
            print("Run out of primes")
            break
        if (not can_be_written_in_goldbach(odd_composite_number, primes)):
            print("Solution is: {}".format(odd_composite_number))
            break
        print("{} can be written in goldbach".format(odd_composite_number))


def can_be_written_in_goldbach(number, primes):
    for prime in primes:
        if (prime > number):
            return False
        if (math.sqrt((number-prime)/2).is_integer()):
            print("s={} prime={}".format(math.sqrt((number-prime)/2), prime))
            return True
    raise ValueException("Jeszcze nie wiem")

def odd_composite_number_generator(primes):
    i = 9
    while True:
        i += 2
        while (i % 2 == 0 or i in primes):
            i += 2
        yield i

if __name__ == '__main__':
    main()

>>138344

Poprawiłem trochę czytelność. Chyba.

#!/usr/bin/python3
import math
import sys
sys.path.append("/home/jaca/project_euler")
from sieve_prime import sieve_primes

def main():
    primes = sorted(set(sieve_primes(10**4)))
    primes_max = max(primes)
    number_generator =odd_composite_number_generator(primes)
    odd_composite_number = next(number_generator)
    while can_be_written_in_goldbach_notation(odd_composite_number, primes):
        if odd_composite_number > primes_max:
            print("Run out of primes")
            break
        print("{} can be can_be_written_in_goldbach_notation")
        odd_composite_number = next(number_generator)
    print("Solution is {}".format(odd_composite_number))

def can_be_written_in_goldbach_notation(number, primes):
    if number in primes:
        return False
    for prime in primes:
        if (prime > number):
            return False
        if (math.sqrt((number-prime)/2).is_integer()):
            print("s={} prime={}".format(math.sqrt((number-prime)/2), prime))
            return True
    return False

def odd_composite_number_generator(primes):
    i = 9
    while True:
        i += 2
        while (i % 2 == 0 or i in primes):
            i += 2
        yield i

if __name__ == '__main__':
    main()

>>138344

>Python ma wbudowany operator na potęgowanie jak wklepiesz x**y to Ci wyskoczy x do y.

dzięki za przypomnienie, chociaż z tego co kojarzę to po prostu skrót do 'pow()'

U mnie też działa po przerobieniu na iterację

class p46():
	def oblicz(self, n, prime):
		kw2x = lambda x : 2*pow(x,2)
		x = 1
		wynik = 0
		while wynik <= n:
			wynik = prime + kw2x(x)  
			if wynik == n: return [prime, x]
			elif wynik > n:
				try: prev_prime = sympy.prevprime(prime)
				except ValueError as e: 
					if e.__str__()=='no preceding primes': return []
				return self.oblicz(n, prev_prime)
			x+=1
	def start(self):
		t1 = time()
		n = 2
		while True:
			if not sympy.primetest.isprime(n) and n % 2 != 0:
				wynik = self.oblicz(n, sympy.prevprime(n))
				if not wynik: 
					print('Liczby nie można przedstawić jako sumy liczby pierwszej i dwukrotności kwadratu: ' + str(n))
					print('Ukończono w: {} s'.format(round(time()-t1, 6)))
					return
#				else: print('{} = {} + 2* {}^2'.format(str(n), str(wynik[0]) , str(wynik[1])))
			n+=1

Twój kod działa szybciej

λ pyth euler_anon.py
Solution is: 5777. Time: 0.156236 s

>>> p46.start()
Liczby nie można przedstawić jako sumy liczby pierwszej i dwukrotności kwadratu: 5777
Ukończono w: 0.765576 s

Ja nastawiłem się na jakąś ogromną liczbę jak w poprzednim zadaniu i w takim przypadku generowanie, sortowanie i przeszukiwanie całej listy liczb pierwszych byłoby kosztowne. Wystarczy zmienić w twoim kodzie na (10**6) i rozwiązanie zajmuje 8.3 s.

Dobry tred.

Jakby spadał to fajnie by było przenieść na /id.

>>138363

Na \id\ ktoś jeszcze wchodzi?

>>138363

To macie jeszcze moje rozwiązanie, ja zrobiłem sito rozwiązań, a potem podoptymalizowałem skrypt i dopracowałem warunki brzegowe.

#!/usr/bin/env ruby
bgn = Time.now

primes = (2..).lazy.filter { |i| (2..Math.sqrt(i)).all? { |j| i % j != 0 } }

require 'set'
sieve = Set.new

PRIMES = 800
MAXMUL = 100

min_empty = 2
ps = primes.take(PRIMES).force
pset = ps.to_set

good_cand = proc do |k|
  k > 1 && (k%2)==1 && !sieve.include?(k) && !pset.include?(k)
end

ps.each do |i|
  (1..MAXMUL).each do |j|
    r = i + 2*j*j
    
    if good_cand.call(r)
      sieve.add(r)
      
      (min_empty..r).each do |k|
        if good_cand.call(k)
          min_empty = k
          break
        end
      end
    end
  end
  
  if i > MAXMUL*MAXMUL
    puts "Out of squares"
    exit
  end
  
  if i > min_empty
    puts "Result: #{min_empty}. In: #{Time.now - bgn}"
    exit
  end
end

puts "Out of primes"

z nudów jeszcze 47 zrobiłem

class p47():
	"""
	The first two consecutive numbers to have two distinct prime factors are:

	14 = 2 × 7
	15 = 3 × 5

	The first three consecutive numbers to have three distinct prime factors are:

	644 = 2² × 7 × 23
	645 = 3 × 5 × 43
	646 = 2 × 17 × 19.

	Find the first four consecutive integers to have four distinct prime factors each. What is the first of these numbers?
	"""
	DIST = 4 #ilość unikalnych czynników pierwszych
	OCZEK_WYNIK = 4 #wymagana ilość następujących po sobie liczb
	def start(self):
		t1 = time()
		i = 2
		wyniki = [] #aktualne następujących po sobie liczby z zadaną ilością unikalnych czynników pierwszych
		while True:
			w = sympy.primefactors(i)
			if len(w) == self.DIST: wyniki.append([i, w])
			else: wyniki = []
			if len(wyniki) == self.OCZEK_WYNIK:
				print("Najniższa sekwencja {} następujących po sobie liczb z {} unikalnymi czynnikami pierwszymi:".format(self.OCZEK_WYNIK, self.DIST))
				for i, w in wyniki:
					print('{} =  {}'.format(str(i), ' x '.join([str(z) for z in w]))) 
				print('Czas: {} s.'.format(round(time()-t1,6)))
				return
			i+=1

Chociaż to banał jeżeli jest biblioteka z funkcją podającą czynniki pierwsze.

Anony od Project Euler przejmowali kiedyś flagi (ang. CTF)? Zrobiłem takiego mini CTF'a, więc możecie spróbować

https://jacadzaca.github.io/

https://picoctf.com też jest ok

O nie, to kodziarze :(