Progressioni aritmetiche dello stesso colore

15

Il teorema di Van der Waerden lo dice

Per ogni dato intero positivo re kc'è un numero Ntale che se gli interi {1, 2, ..., N}sono colorati, ognuno con uno di r colori diversi, allora ci sono almeno knumeri interi in progressione aritmetica dello stesso colore. Il minimo Nè il numero di Van der Waerden W(r, k).

Il vostro obiettivo è quello di calcolare i Van der Waerden numero W(r, k)dato input positivo-interi re k. Vince il minor numero di byte.

Attenzione che questa funzione cresce molto rapidamente e richiede molto tempo per essere calcolata. Anche W(4, 4)è sconosciuto. Puoi presumere che il tuo codice venga eseguito su un computer ideale con risorse illimitate (tempo, memoria, profondità dello stack, ecc.). Il tuo codice deve teoricamente dare la risposta giusta anche per valori per i quali la risposta non è nota.

Gli incorporati che calcolano questa funzione non sono ammessi.

Esempio

Per i r = 2colori e le progressioni di lunghezza k = 3, esiste una 8sequenza di lunghezze che evita tale progressione, cioè 3elementi equidistanti dello stesso colore:

B R R B B R R B

Ma non esiste una tale 9sequenza di lunghezza , quindi W(2, 3) == 9. Per esempio,

R B B R B R R B R
  ^     ^     ^

contiene la 3progressione aritmetica dello stesso colore della lunghezza mostrata.

Casi test

Probabilmente sarai in grado di testare solo piccoli casi.

+-----+-----+-----+-----+-----+-----+------+
|     | k=1 | k=2 | k=3 | k=4 | k=5 | k=6  |
+-----+-----+-----+-----+-----+-----+------+
| r=1 |   1 |   2 |   3 |   4 |   5 |    6 |
| r=2 |   1 |   3 |   9 |  35 | 178 | 1132 |
| r=3 |   1 |   4 |  27 | 293 |     |      |
| r=4 |   1 |   5 |  76 |     |     |      |
+-----+-----+-----+-----+-----+-----+------+

Mostra snippet di codice

code-golf  math  sequence  combinatorics  subsequence 
— XNOR
fonte

Risposte:

7

Python 3.5, 125 124 119 byte

f=lambda r,k,*L:any(L[:x*k:x]==k*(*{*L[:x*k:x]},)for x in range(1,len(L)+1))*len(L)or max(f(r,k,i,*L)for i in range(r))

È divertente perché, nel corso del golf, questo programma è diventato effettivamente più efficiente. Tuttavia, qualsiasi cosa oltre f(2,4)o f(3,3)richiede ancora un'eternità.

Spiegazione

La versione iniziale ha verificato se una sequenza conteneva una progressione di lunghezza kprovando tutti i possibili indici e passaggi iniziali.

def f(r,k,L=[]):
 for i in range(len(L)):
  for j in range(len(L)):
   if len(set(L[i::j+1]))==1 and len(L[i::j+1])==k:
    return len(L)
 return max(f(r,k,L+[i])for i in range(r))

La versione golfizzata deve solo provare tutti i passaggi possibili poiché antepone nuovi elementi di sequenza. Il x*klimite deve occuparsi di casi simili [0, 0, 1], che contengono una progressione di lunghezza 2 ma non soddisferebbero il controllo di unicità non coperto.

Per quanto riguarda il controllo

L[:x*k:x]==k*(*{*L[:x*k:x]},)

Al primo passaggio della versione golfata, quando Lè vuoto, len(L)è 0. In questo modo la seconda metà orverrà sempre eseguita. Dopodiché Lnon è vuoto, quindi {*L[:x*k:x]}(che è solo Python 3.5 per set(L[:x*k:x])) avrà almeno un elemento.

Poiché L[:x*k:x]può avere al massimo kelementi e per Lnon vuoto k*(*{*L[:x*k:x]},)ha almeno kelementi, i due possono essere uguali solo quando ci sono esattamente kelementi in entrambi. Perché ciò accada {*L[:x*k:x]}deve avere esattamente un elemento, cioè abbiamo solo un colore nella nostra progressione.

— SP3000
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.