Je trouve la suite suivante :
R-N-N-R-N-N-R-N-R-N-N-R-N-R-N-N-R-N-N-R
soit 20 cartes avant que le prochain joueur joue N et gagne.

Drôle d'odeur de poisson tout à coup.

Bonjour jamo,

_{Pas évidente celle-ci...}

Je propose une suite maximale de 17.

Voici les coups : R N N R N N R N R N N R N R N N R.

Bonjour,

^{hum pas facile d'être exhaustif dans ce type de recherche...}

Je pense que la plus longue suite est de 17 cartes:
Deux séries sont possibles à 16 cartes (sans répétition): RNNRNNRNRNNRNRNN ou NNRNRNNRNRNNRNNR
Dans le premier cas, on ne peut que jouer R et il vient une répétition de taille 5: NRNNR-NRNNR-NRNNR
Dans le second cas, on ne peut que jouer N et il vient une répétition de taille 3: NRN-NRN-NRN

Les 4 séries de taille 17 terminant une partie sont donc:
RNNRNNRNRNNRNRN-N-N
RNNRNNR-NRNNR-NRNNR
NNRNRNNRNRNNRNNR-R
NNRNRNNRNRN-NRN-NRN

Ma recherche a porté sur les répétitions de blocs de 2 (RN/NR), de 3 (RNR/NRN/RNN/NNR), de 4 (Nada, ouf!) et de 5 (NRNRN/RNNRN/NRNNR/RNRNN/NNRNR) à l'aide d'un gros arbre pas joli à voir...

Merci jamo pour cette énigme passionnante.

Bonjour,

R N N R N R N R N N R N R N N R N  R N N R N R N R N N R N R N N R N  R N N R N R N R N N R N R N N R N.

Voilà une réponse qui me parrait plaussible !!

Bonjour,

Je tente une partie qui s'arrête au 17ème coup :
16 premiers coups : NNR NR NNR NR NNR NNR
Le 17 ème coup (N ou R) arrête la partie.

Merci pour cette énigme pas si simple .

Les parties les plus longues se jouent en 17 coups :

{17, "RNNRNNRNRNNRNRNNR"}


voilà un façon de les énumérer avec Mathematica.

Bonjour Jamo,

ma séquence à permutation circulaire près : partie terminée à la 24^ème carte tirée.




Merci pour cette énigme.

NNRNNRNRNNRNRNN

Bonjour Jamo,

La plus longue partie jouable est de 16 coups.
Soit par ex:
NN RN RN NR NR NN RN NR.
Merci pour l'enigmo.

Bonjour

Bon, si je ne me suis pas planté dans mon raisonnement, je dirais que le mieux est une série de 17 coups...
et j'ai deux séries qui conviennent :

RNNRNNRNRNNRNRNNR
ou
NNRNRNNRNRNNRNNRN

mm

Il n'y a pas de limite il suffi d'alterner les petites séries "RN" et "RNN" en évitant les grandes séries de la forme : (RNN RN RN) (RNN RN RN) (RNN RN RN)

ex: RNN RN RNN RNN RN RNN RNN RN RN RNN RNN RN RNN RN RN RNN RN RNN RN RN RNN RN RNN RN RN RNN

Ma séquence était trop courte, tant pis pour moi, je me suis aperçu qu'il y avait une petite faille dans mon programme.

Pour ceux que ça intéresse voici toutes les solutions :

{R, N, N, R, N, N, R, N, R, N, N, R, N, R, N, N}

{N, N, R, N, R, N, N, R, N, R, N, N, R, N, N, R}

Il faudrait que les cartes partent dans cet ordre: NRNRNNRNRNNNRNRNNNN...et ainsi de suite.
Bon je ne suis pas sur du tout par contre!

Bonjour Jamo,

Je propose une longueur maximale de 16 cartes jouées comme ceci : R N N R N N R N R N N R N R N N
(ou bien : N N R N R N N R N R N N R N N R, ce sont les deux seules solutions)

Merci pour l'énigme !

Bonsoir,
je ne sais pas si je peux poster là mais je ne comprends pas très bien l'énigme , quand on dit un jeu de cartes classique c'est 32 cartes ou 54 ? et s'il est classique comment on peut considérer que le nombre de cartes est suffisamment important (voir infini)?

Bonsoir
Sans doute en 16 coups
NNRNRNNR NRN NRN NR : si le coup suivant est R la partie est terminée ( RR pour finir)
et si c'est N on a 3 fois de suite NRN et la partie est terminée
A+

J'ai trouvé 4 parties d'une longueur maximale de cartes. Par exemple :

Bonjour, je propose vraiment sans conviction une partie à 26 coups

R NNR NNR NR NNR NNR NR NNR NNR NNR

J'attends mes arrettes de poisson et j'attends surtout de voir les méthodes de résolution des gens intelligents.

Bien a vous.
Math is good but math is hard!

Bonjour,
Rien n'interdit que la couleur noire "sorte" 5 fois de suite;
on peut donc imaginer une série:
NNNNN R NNNNN R NNNN R NNNN R NNNNN R NNNNN R NNNN R NNNN R NNNNN R NNN R NNNNN R NNNNN R NNNN R
en alternant les séries  de 5 N de  4 N  de 3 N et leurs panachages ,je ne
vois pas une réponse courte cohérente

NNR NRN NRN RNN RNR NN + 17

Ma réponse est:
"NRNNRNRNNRNRNRNNRNRNNRNRNRNNRNRNNRNR"
36 cartes

Bonjour et merci pour cette énigme
La plus longue série que je trouve est la suivante :
"RNNRNNRNRNNRNRNNR" soit 17 cartes.
Je croise les doigts ^^

Bonjour ,

je propose:
RNNRNNRNRNNRNRNN
NNRNRNNRNRNNRNNR

les deux plus longues suites avec une longueur de 16 que j'ai trouvées en testant toutes les combinaisons.

pas pris le temps de beaucoup y réfléchir mais je pense que la solution doit être du type
NNRNNRNRNNRNNRNRNNRNNRNR
(avec quelques permutations possibles)
soit 24 cartes au total.

NNRNRNNRNRNNRNRNNRNRNNRNRNNRNRNNRNRNNRNRNRNRR  Suite de 45 cartes

Bonjour,

J'ai trouvé :
Taille 16
RNNRNNRNRNNRNRNN

(et il y en a une autre : le miroir de celle-ci)

Clôture de l'énigme

Voilà une énigme qui n'était pas si facile que ça !!

Pour la plus longue partie, j'ai accepté 2 types de réponses : celles à 16 et celles à 17.
En effet, on peut placer au maximum 16 cartes sans les répétitions interdites, donc on peut aussi considérer que la plus longue partie s'arrête lorsqu'on pose la 17ème carte.

Si on se limite aux 16 premières cartes, il n'existe que 2 possibilités : la série suivante ainsi que celle obtenue en la retournant :

NNRNRNNRNRNNRNNR

Pour ceux qui ont récolté un poisson :
1) relisez bien les règles du jeu ;
2) vérifier bien votre série de cartes, elle comporte forcément une répétition quelque part.

Mal compris l'énoncé
Par 3 séquences j'entendais séquence de minimum 2
ex NR NR NR ou NNR NNR NNR ou NRN NRN NRN
donc NN NN NN  me semblait interdit mais pas NN NN NR
Je viens de comprendre que N N N de séquence 1 était aussi interdit

Bonjour,

Pour ceux qui n'ont pas mathématica et qui ne déteste pas la récursivité:


DECLARE FUNCTION Testnum% (s AS STRING, level AS INTEGER)
DECLARE SUB Pause ()
DECLARE FUNCTION Test3% (s AS STRING)
DECLARE FUNCTION RR% (s AS STRING)
DECLARE FUNCTION Deeper% (s AS STRING)
CONST Faux = (0 = 1)
CONST Vrai = NOT (Faux)
DIM SHARED maxi AS INTEGER, sol AS STRING, num AS INTEGER
DIM x AS INTEGER
CLS
OPEN "c:\223\223.txt" FOR OUTPUT AS #2
  x = Deeper("")
  PRINT #2, maxi, sol
  PRINT maxi, sol
CLOSE #2
END

FUNCTION Deeper% (s AS STRING)
SHARED maxi AS INTEGER, sol AS STRING, num AS INTEGER
DIM ret AS INTEGER, x AS INTEGER
  CALL Pause

  IF LEN(s) > 80 THEN END

  ret = Vrai
  IF RR%(s) THEN
   'PRINT "RR est vrai<"; s; ">"
   ret = Faux
  ELSE
   IF Test3%(s) THEN
    ret = Faux
   ELSE
    x = Deeper%(s + "0")
    x = Deeper%(s + "1")
   END IF
  END IF
  IF ret THEN
   IF LEN(s) > maxi THEN
    maxi = LEN(s)
    sol = s
   END IF
  PRINT #2, LEN(s), s, num
   PRINT "fin"; s
   'END
  END IF
Deeper% = ret
END FUNCTION

SUB Pause
y$ = INKEY$
  IF y$ = CHR$(27) THEN END

END SUB

FUNCTION RR% (s AS STRING)
DIM ret AS INTEGER
  ret = Faux
IF LEN(s) > 1 THEN
  IF RIGHT$(s, 2) = "11" THEN
   ret = Vrai
  END IF
END IF
RR% = ret
END FUNCTION

FUNCTION Test3% (s AS STRING)
SHARED num AS INTEGER
DIM ret AS INTEGER, x AS INTEGER, i AS INTEGER
  ret = Faux
  x = INT(LEN(s) / 3)
  IF x > 0 THEN
   FOR i = 1 TO x
    IF Testnum%(s, i) THEN
     num = i
     ret = Vrai
     EXIT FOR
    END IF
   NEXT i
  END IF
Test3% = ret
END FUNCTION

FUNCTION Testnum% (s AS STRING, level AS INTEGER)
DIM ret AS INTEGER, le AS INTEGER, a1 AS INTEGER, a2 AS INTEGER, a3 AS INTEGER
DIM s1 AS STRING, s2 AS STRING, s3 AS STRING
  ret = Faux
  le = LEN(s)
  a3 = le - level: s3 = MID$(s, 1 + a3, level)
  a2 = a3 - level: s2 = MID$(s, 1 + a2, level)
  a1 = a2 - level: s1 = MID$(s, 1 + a1, level)
  IF s1 = s2 THEN
   IF s2 = s3 THEN
    ret = Vrai
   END IF
  END IF
Testnum% = ret
END FUNCTION

détestent

Bonsoir,

Dans l'esprit de Caylus mais davantage destiné aux anciens/actuels/futurs taupins :

(*enigmo 213*)

let test jeu = let n=string_length jeu and s=ref "" and b=ref true and i=ref 1 in
  while !i<=n/3 && !b=true do
    s:=sub_string jeu (n- !i) !i ;
    if !s=(sub_string jeu (n-2* !i) !i) then if !s=(sub_string jeu (n-3* !i) !i) then b:=false
                                                                           else ()
                                     else () ;
   i:=1+ !i
  done;
  !b;;

let find () = let L=ref ["n";"r"] and i=ref 0 and K=ref [] and M=ref [] and s=ref "" in
  while (list_length !L)>1 do
      M:= !L;
    for j=1 to (list_length !L) do
      s:=hd( !L) ;
      if (!s).[ !i]=`r` then if test (!s^"n") then K:= (!s^"n") :: !K else ()
                     else (if test (!s^"n") then K:= (!s^"n") :: !K else () ;
                           if test (!s^"r") then K:= (!s^"r") :: !K else () );
      L:=tl !L ;
      done;
    i:= !i+1 ;
    if !K<>[] then (L:= !K ; K:=[] ) else () ;
  done;
!M;;

let solut=find ();;
string_length (hd(tl solut));;


Je ne garantis pas l'optimalité de l'algo.

Bonsoir à tous

Comme je vous envie caylus et Noflah entre autres !