BATTLE 2048 : VIENDEZ VOUS FIGHTER !!!

oui c'est nettement moins impressionnant quand on passe aux logarithmes !

En attendant j'ai battu mon record pour la 2048



Par contre la 4096 chuis pas prêt de la recoller je pense

ⓗⓞⓤⓢⓔ a écrit:

Thaïti Bob a écrit:si il n'y avait pas un facteur chance, l'être humain ne jouerait à aucun jeu, car il ne les aurait pas inventé pour se divertir ;)C'est la définition d'un jeu !

Bah non, certains jeux sont basés exclusivement sur la stratégie, la chance n'a aucun rôle (les échecs, les dames, etc...)

Pour ceux que ça intéresse, il y a un essai de Roger Caillois assez intéressant sur la question, il s'intitule "Les jeux et les hommes". Il distingue les jeux de compétition, de hasards, de mime et de vertige... http://ide-edu.net/2011/11/les-jeux-et-les-hommes-essai-de-roger-caillois/

Assez marrant comme jeu sinon

version darwin : http://games.usvsth3m.com/2048/darwin-edition-3/

Ha ha excellente, j'ai eu Darwin du premier coup mais on ne peut pas continuer après, jusqu'à Scarlett Johanson!

Scarlett Johansson ? Ah, là, je suis motivé !   Pour l'instant, je n'ai atteint qu'un pauvre diplodocus, je suis loin de Scarlett...

Edit partie suivante : Un tyrannosaurus.

rah j'ai fait 2 parties et les 2 je suis arrivé au gorille. (il y a autre chose entre le gorille et le tyrannosaure) et en plus j'avais presque 2 gorilles

allez encore des remakes : http://ecrans.liberation.fr/ecrans/2014/04/01/2048-la-guerre-des-clones_992204

Et rebim...



Et record de points battus

3e 4096 placée... Et pitaiiiin j'ai fait une erreur débile après, trop con j'aurais pu péter mon record... Mort à 55 000 tant pis.

Ahum... (en effet y a un p'tit côté addictif)

Allez, pour laisser tout de même une trace de 3h de lutte - et parce que le score est esthétique   

2048, score : 20480

20480 joli

Bon j'ai toujours pas compris un truc perso : le but c'est de faire plus ou moins de points quand on fait la 2048? J'aurais dit "plus", mais le fait est que quand je joue classe "sans déchets", je fais moins de points...

au regard de mes exploits récursifs et mon impossibilité à atteindre une 2nde fois le 2048, je propose un concours de défaite la plus rapide !
pour moi : 1656 pts, et même pas voulu.

Désolé, mais je viens de défoncer mon record



Par contre la partie devient longue... Mais GROS regret, UNE faute d'inattention qui m'a latté, j'ai décollé le 4096 UNE FOIS et me suis retrouvé avec un 2 à côté  ... Enfin bon je suis parvenu à coller un 2048 à côté ensuite quand même :


 et je n'étais pas loin du 1024, quasiment 30 000 points après le 4096 ça va chuis content

Pas encore réussi le 4096. Mon attention baisse - (ça serait intéressant de voir ce qui se passe au niveau du cerveau quand on joue à ça. C'est un peu comme si on ''s'auto-configurait''. Je n'irais pas jusqu'à dire que c'est un état de conscience modifié... mais...)

Sinon, house, autre moyen de se mesurer : par rapport au temps (- mode cassandre - va y avoir la fonction chronomètre un de ces quatre, afin que les concurrents qui arriveront facilement à 2048 puissent se départager, et soient encore dans l'émulation)

J'arrêterai alors de jouer, je déteste les montres, chronomètres, et mesures de ce type

Enfin je jouerai dans mon coin plutôt

En pratique comme tu le dis, on est dans l'automatisme et je joue super vite, mais si tu veux me stresser, tu me colles un chrono  Qu'est-ce que j'ai pu me prendre la tête avec mes potes qui voulaient jouer aux échecs en blitz, alors que pour moi le but est de se détendre, de réfléchir posément, caaaaalme...

Ahhh, on a trouvé la faille !

- je suis exactement pareil concernant le chronométrage, cela dit.   -

Je fais 3-4 parties et puis ça me gave pour deux jours, pour ma part. Addiction 0 (et résultats aussi, forcément).

Veinard

Le score maximum étant (si je ne me suis pas planté) 917506, vous avez encore de la marge  

(EDIT : en supposant qu'on ne reçoit que des 2)

124 au minimum de points j'ai eu un coup de bol c'est pas si facile que ça !

Et je trouve 20480 comme score minimal parfait pour faire afficher la case 2048 !
edit : et pareil en supposant qu'on recoit que des 2. donc le score mini peut être encore un poil plus petit

Sympa ce p'tit jeu !   
Je n'ai pas senti de grosse addiction mais je pense que je m'en ferai 2-3 de temps en temps.
Sinon, dommage que ça s'arrête à 2048.

Y'a des gars qui ont collé la 8192 (ou qui ont photoshop)

FadeToBlack a écrit:Sympa ce p'tit jeu !   
Je n'ai pas senti de grosse addiction mais je pense que je m'en ferai 2-3 de temps en temps.
Sinon, dommage que ça s'arrête à 2048.

Bah non justement, tu cliques sur "keep going" et ça continue, à toi la 4096!!!

ⓗⓞⓤⓢⓔ a écrit:Bah non justement, tu cliques sur "keep going" et ça continue, à toi la 4096!!!

Merde, quel boulet !!!  

Thaïti Bob a écrit:
Et je trouve 20480 comme score minimal parfait pour faire afficher la case 2048 !
edit : et pareil en supposant qu'on recoit que des 2. donc le score mini peut être encore un poil plus petit

Beaucoup plus petit : avec que des 2 c'est 10256 points.

ⓗⓞⓤⓢⓔ a écrit:Y'a des gars qui ont collé la 8192 (ou qui ont photoshop)

C'est possible parce que le maximum qu'on peut avoir (toujours qu'avec des 2) c'est 65536.

Quel est ton calcul? (pour les points comme pour les tuiles)

Je n'ai même pas regardé comment les points fonctionnaient je l'avoue, on gaule le nombre de points de la tuile créée tout bêtement?

ⓗⓞⓤⓢⓔ a écrit:Quel est ton calcul? (pour les points comme pour les tuiles)

Je n'ai même pas regardé comment les points fonctionnaient je l'avoue, on gaule le nombre de points de la tuile créée tout bêtement?

C'est ça.

Un petit code qui simule le cas idéal. Quelques lignes valent mieux qu'un long discours :

Code:

program test
integer(8), dimension(16) :: nbres
integer(8) :: score

score = 0
nbres = 0
do i = 1, 1000000
  k = 16
  do while ((nbres(k) == 0).and.(k>0))
    k = k - 1
  enddo
  nbres(k+1) = 2
  do k = 1, 15
    if ((nbres(k)==nbres(k+1)).and.(nbres(k)/=0)) then
      score = score + nbres(k)
      nbres(k) = 2*nbres(k)
      do j=k+1, 15
        nbres(j) = nbres(j+1)
      enddo
      nbres(16) = 0
     endif
   enddo
  write(10,*) i, count(nbres/=0)
  if (count(nbres/=0)==16) then
    write(*,*) 'STOP : ', sum(nbres),maxval(nbres), i, score
    stop
  endif
!   if (any(nbres==2048)) then
!     write(*,*) 'STOP : ', sum(nbres),maxval(nbres), i, score
!     stop
!   endif
enddo
end program


Ca me permet entre autre d'accéder au taux de remplissage minimum de la grille en fonction du nombre d’itérations. Et comme je le présageais : à mesure du temps le maximum augmente forcément, donc il y a un maxima d'empilement possible.

Ok, je te crois sur parole  (chapeau  )

J'entrave woualou à ton code, mais au final je vous poutre tous        

Pas de soucis.

Quant au score minimum, si vraiment on a pas de bol avec les 2 et les 4, on obtient un quadrillage de 2 et de 4 => ça fait 0.

pas bien compréhensible...stu pouvais le commenter stp ?
Moi j'ai fait au plus simple, mais du coup, au risque de ne pas être assez proche des réalités du jeu et ses règles (rester dans un carré de 4x4 cases).
Prenons un exemple :
16 = 2⁴ = 2x2 + 2x2 + 2x2 + 2x2
           = 4    +   4   +   4  +   4   points gagnés quand on assemble les tuiles "2"
           =       8        +       8        points gagnés ajoutés quand on assemble entre elles les tuiles "4"
           =                 16              points encore ajoutés au score total
Total des points amassés pour faire apparaitre la tuile 16 :  T= (4-1)x16 = 48
Et ce quels que soient les mouvements faits donc.

Généralisation :
En faisant apparaître la tuile 2^k, au cours du jeu idéal, on amasse : (k-1)x2^k
2048 = 2¹¹ donc k=11
Donc pour gagner le jeu, le score minimal est de 10x2048 = 20480.

Vous êtes d'accord ??

lool house
ah oui c'est vrai hobb pour le score mini. Mais faudrai vraiment mais vraiment pas avoir de bol du tout !!

Ben c'est le cas minimal, je n'ai pas dit qu'il était fréquent ^^

Quant à commenter le code... on a une liste de jetons, on rajoute un 2 à droite et on réduit, ce qui revient au cas idéal où les nombres suivent un serpentin de 4x4 cases, et tous en ordre croissant sur ce serpentin..
le while c'est pour trouver la première case où il n'y a pas de jeton, pour mettre un 2. La boucle d'après c'est pour réduire tous les jetons identique consécutifs (au passage on incrémente le score etc)..

Voilà voilà

Thaïti Bob a écrit:pas bien compréhensible...stu pouvais le commenter stp ?
Moi j'ai fait au plus simple, mais du coup, au risque de ne pas être assez proche des réalités du jeu et ses règles (rester dans un carré de 4x4 cases).
Prenons un exemple :
16 = 2⁴ = 2x2 + 2x2 + 2x2 + 2x2
           = 4    +   4   +   4  +   4   points gagnés quand on assemble les tuiles "2"
           =       8        +       8        points gagnés ajoutés quand on assemble entre elles les tuiles "4"
           =                 16              points encore ajoutés au score total
Total des points amassés pour faire apparaitre la tuile 16 :  T= (4-1)x16 = 48
Et ce quels que soient les mouvements faits donc.

Généralisation :
En faisant apparaître la tuile 2^k, au cours du jeu idéal, on amasse : (k-1)x2^k
2048 = 2¹¹ donc k=11
Donc pour gagner le jeu, le score minimal est de 10x2048 = 20480.

Vous êtes d'accord ??

Nope, je fais souvent moins, et mon record c'est 20 088 pour la tuile 2048, y'a une couille quelque part

hobb merci je regarderai ça, pas trop la forme maintenant
En tout cas pour mon calcul, je suis allé vérifié en jouant. Au moment où j'affichais la tuile 1024 et en n'ayant pas joué comme un pied, j'avais bien un score tournant au dessus de 9216 (=9*1024 comme donné par ma formule). Et j'ai vérifié la bonne application du théorème de récurrence

edit : house : ouép, mais tu peux faire moins, car il apparait des"4" souvent et donc tu marque d'autant moins de score que de nombre de fois où sont apparues des tuiles "4" que tu n'as pas eu à fusionner (elles te donnent à chaque fois 4 points). et ça, l'apparition aléatoire de 4 au lieu de 2 tout le temps, difficile de l'intégrer au calcul...Ah si, en calculant par exemple le score que tu ferait pour faire afficher la tuile 2048, si que des 4 tombaient par exemple et jamais de 2. Ou alors 1 fois sur 2 etc.

Okidok, ceci expliquant cela bien vu

Thaïti Bob a écrit:. Et j'ai vérifié la bonne application du théorème de récurrence

la récurrence est toute bête. Tu as 2^1, 2^2 ... 2^16 en remplissage de grille optimale, ce qui fait un nombre de point, pour chaque N (pour le nombre 2^N) de points en u_n = n/2 + 2 u_{n-1}. Si tu as une formule exacte à me proposer pour la somme des u_n, ça résoudrait le problème qu'on se pose.

Pendant que vous récurez, j'ai collé un nouveau 4096, avec un 1024 et un 512 à côté dans le bon ordre

Au cas où, pour ceux qui voudraient varier les plaisirs...  

Voici le démoniaque 2^53 

http://www.csie.ntu.edu.tw/~b01902112/9007199254740992/

ou le double...
http://baiqiang.github.io/2048-double/

ⓗⓞⓤⓢⓔ a écrit:Pendant que vous récurez, j'ai collé un nouveau 4096, avec un 1024 et un 512 à côté dans le bon ordre

Et dire que j'étais toute fière d'atteindre 4096...

hobb merci pour ta réponse. de mon côté je vais essayer de poser le plus de choses possibles pour bien être d'accord de quoi on parle.
Pour mon raisonnement que j'ai développé dans le message précédent et où je voulais vous demander si vous étiez d'accord, je voulais calculer le score qui est apporté par le processus de création de la tuile 2048, en fusionnant des tuiles de "2" entre elles et ainsi de suite. Le but est de calculer le score MINIMAL, avec comme fin de jeu, une seule tuile sur le plateau tout propre : "2048".
Mes hypothèses sont :
- on s'affranchit de la taille du plateau et des contraintes liées aux mouvements pour jouer (c'est ici en fait la grosse différence avec TES calculs je crois )
- n'apparaissent que des 2,
- on imagine que chaque "2" est utilisé à bon escient vers la création de la tuile 2048.
J'ai voulu prouver par récurrence que pour tout n, le score cumulé total est de : T(n) = (n-1)*2^n
J'ai initialisé en voyant que ça marche pour n = 4 pour le score de la tuile "16". pour "8", et 4 c'est immédiat.
De mon côté sur papier, j'ai calculé T(n+1) pour voir si je pouvait l'exprimer sous la même forme. pour voir si ça marche donc quand on augmente n au rang suivant, soit pour la tuile suivante. Et j'obtiens bien en quelques étapes, T(n+1) = (n+1 -1)*2^(n+1). Ce qui prouve la récurrence. (en se faisant un ptit schéma où l'on déroule la pyramide des points par exemple pour la tuile 16 créés en tuiles de 2 puis en tuiles de 4 puis 8 puis etc., puis en voyant ce qui se passe quand on veut regarder la pyramide des points pour une tuile supérieure). Ca parait assez sombre comme ça mais si on se fait un ptit schéma on voit vite.

Voilà.
Pour moi, on peut arriver en un jeu idéal, à un plateau tout vide avec seule la tuile 2048 dans un coin. Peut être que c'est pour ça que je me plante, j'en suis pas tout à fait sûr. (ça pourrait se prouver par récurrence certainement aussi !)

Ensuite, pour toi hobb, je suis pas sûr d'avoir bien compris ce que tu calculais en fait. Pour qu'on se comprenne mieux, est ce que tu peux bien tout expliquer ce que tu fait et avec un voc précis comme j'essaie de faire. Style quand tu parles d'une tuile, tu utilise des guillemets etc.
Si tu fonctionne avec ton serpentin, rempli avec un "2048", un "1024"..., un "2", c'est qu'on calcule la somme de k = 1 à 11, de tous mes T(k) précédemment étudiés. Et ça, une feuille excel fait le job.
En fait, je ne voit pas de moyen de faire moins de points que ce que j'ai montré, n'importe quoi en ferait plus selon moi, peut être que je me plante. Cependant, ma formule a l'air plutôt précise car à quelques dizaines près de points, je l'ai vérifié à chaque étape en jouant jusqu'à la tuile "1024".

Je vais me pencher sur ta suite définie par récurence pour mieux voir ce qu'elle représente.

Ha d'accord, donc effectivement on ne voyait pas la même chose. Le score minimal avec une seule brique de 2048. C'est effectivement le cas minimal.

Alors pour avoir 2048, il faut 2 1024 (-> 1024 points)
pour avoir un 1024, il faut 2 512 (-> 512 points).

Donc, pour avoir 2048, on obtient 1024 + 2* le nombre de points pour créer les 1024.
Pour avoir 1024, on obtient 512+2*le nombre de points pour créer les 512.
Etc...

Donc, pour avoir u_n, on obtient n/2 + 2u_{n-1}. Il faut donc calculer u_2048 (en décrémentant n par puissance de 2).
Résolution numérique jusqu'à 2^20 :

Code:

program test
integer u
u  = 0
i = 2
do k=1, 20
i = i*2
u = i/2+2*u
write(*,*) i, u
enddo
end program

          4           2
          8           8
         16          24
         32          64
         64         160
        128         384
        256         896
        512        2048
       1024        4608
       2048       10240
       4096       22528
       8192       49152
      16384      106496
      32768      229376
      65536      491520
     131072     1048576
     262144     2228224
     524288     4718592
    1048576     9961472
    2097152    20971520

A 2048, avec une seule tuile, on aura donc au minimum 10240 points, ce qui coïncide PRESQUE le code que j'avais fait et qui obtient à 2048 une seule brique pour un score de 10256.

Ca c'est marrant cette différence de 16 points. Je regarde d'où ça peut venir (mon premier code étant pour moi le cas idéal).

EDIT : je viens de trouver la différence (la vache, c'est subtil). En fait un ne peut pas avoir une seule brique (sauf avec le premier 4). Quand on réduit une séquence par exemple 8 4 4, on obtient 8 8 ET 2 (le nouveau) qu'on réduit ensuite en 16 2 ET 2 etc.... Donc à part le premier 4, une seule brique contenant 2048 est impossible. Ca, c'est mon premier code qui en a rendu compte, et l'approximation qui est faite dans la récurrence qu'on a définit au dessus c'est que ça n'en rend pas compte.

Concernant la suite de Hobb : u_n = 2 u_n-1 + n/2

Il suffit de remarquer que u_n + n/2 = 2 (u_n-1 + (n-1)/2) + 1.

On pose alors v_n = u_n + n/2, c'est-à-dire que v_n = 2 v_n-1 + 1.

(v_n) est une suite arithmético-géométrique.

On pose w_n = v_n + 1.

(w_n) est une suite géométrique, d'où le terme général et la somme.

En inversant, u_n = w_n - n/2 - 1, d'où la somme recherchée.

Donc le résultat imbrique nécessairement un 2 supplémentaire à chaque réduction de la brique la plus élevée à partir de 4. Donc le résultat final, c'est la somme de ma récurrence + un facteur correctif du à la présence d'autres briques.

Petit test rapide en comparant toutes les puissances de 2 avec une seule brique (ma récurrence) de la simu (obtenu par le code). Colonne de gauche, c'est la brique la plus élevée, la première fois qu'elle apparait. La deuxième (très intéressant) c'est la somme des tuiles présente lors de l'apparition de la plus grosse (on voit une différence avec la première colonne, donc la brique ne PEUT PAS apparaître seule).  La troisième, c'est le nombre d'itérations pour en arriver là. La quatrième c'est le score cumulé au moment où la brique apparaît. La cinquième colonne, c'est ma somme de u_n, et enfin la sixième c'est le facteur correctif (=4°-5° colonne).

Voilà voilà.

Code:


           4           4           2           2           2           0
           8          10           5           8           8           0
          16          20          10          26          24           2
          32          38          19          66          64           2
          64          72          36         164         160           4
         128         138          69         392         384           8
         256         268         134         906         896          10
         512         526         263        2058        2048          10
        1024        1040         520        4620        4608          12
        2048        2066        1033       10256       10240          16
        4096        4116        2058       22554       22528          26
        8192        8214        4107       49178       49152          26
       16384       16408        8204      106524      106496          28
       32768       32794       16397      229408      229376          32
       65536       65564       32782      491554      491520          34



EDIT : message écrit pendant les 2 messages précédant donc ne pas tenir compte des messages de pieyre et hobb juste avant

non il y a une couille dans ton truc, un facteur 2 dans le comptage des points.
Regardes les 2 premiers exemples et compares à la réalité :
Dans le jeu, à l'instant juste après avoir fusionné deux tuiles "2", tu te retrouves avec une tuile "4", et 4 points au compteur, et non pas 2 points comme ton listing le fait penser. idem pour obtenir la tuile "8". Pour obtenir la tuile 4, le nombre minimal de points est bien 4, et non pas 2. Pour la "8", c'est 16 points et non pas 8.Ou alors j’interprète mal ce que tu fais ???
moi j'ai ça comme points au compteur, en fonction des tuiles obtenues
2 0
4 4
8 16
16 48
32 128
64 320
128 768
256 1792
512 4096
1024 9216
2048 20480
4096 45056
8192 98304

A flute, j'étais parti du principe que lorsque tu prends deux 2 pour faire un 4, tu gagnes 2 points et non pas 4.

Erreur de ma part, je refais tout.

Code corrigé :

Code:

program test
integer(8), dimension(16) :: nbres
integer(8) :: score

score = 0
nbres = 0
do i = 1, 1000000
  k = 16
  do while ((nbres(k) == 0).and.(k>0))
    k = k - 1
  enddo
  nbres(k+1) = 2
  do k = 1, 15
    if ((nbres(k)==nbres(k+1)).and.(nbres(k)/=0)) then
      nbres(k) = 2*nbres(k)
      score = score + nbres(k)
      do j=k+1, 15
        nbres(j) = nbres(j+1)
      enddo
      nbres(16) = 0
     endif
   enddo
  write(10,*) i, count(nbres/=0)
  if (count(nbres/=0)==16) then
    write(*,*) 'STOP : ', sum(nbres),maxval(nbres), i, score
    stop
  endif
!   if (any(nbres==2048)) then
!     write(*,*) 'STOP : ', sum(nbres),maxval(nbres), i, score
!     stop
!   endif
enddo
end program

Nouvelle suite : u_n = n + 2 u_{n-1}
Nouveaux résultats :

Code:


           4           4           2           4           4           0
           8          10           5          16          16           0
          16          20          10          52          48           4
          32          38          19         132         128           4
          64          72          36         328         320           8
         128         138          69         784         768          16
         256         268         134        1812        1792          20
         512         526         263        4116        4096          20
        1024        1040         520        9240        9216          24
        2048        2066        1033       20512       20480          32
        4096        4116        2058       45108       45056          52
        8192        8214        4107       98356       98304          52
       16384       16408        8204      213048      212992          56
       32768       32794       16397      458816      458752          64
       65536       65564       32782      983108      983040          68


Le graphique que j'avais mit ne bouge pas, mais le plus faible score si. Le score le plus élevé atteint maintenant 1835012. La plus haute brique est inchangée.

ⓗⓞⓤⓢⓔ a écrit:Ok, je te crois sur parole  (chapeau  )

J'entrave woualou à ton code, mais au final je vous poutre tous        

enfin tous - il faudra plus que ça pour impressionner le "Ludo Typicus"  



(tout était en ordre c'est un mvt de fatigue qui m'a fait baisser la 1ère ligne !^^")

Pas mal pas mal, je note le score, mais ce 4096 doit être tout triste tout seul dans son coin comme ça  

FadeToBlack a écrit:Au cas où, pour ceux qui voudraient varier les plaisirs...  

Voici le démoniaque 2^53 

http://www.csie.ntu.edu.tw/~b01902112/9007199254740992/

ou le double...
http://baiqiang.github.io/2048-double/

Purée jésus de sa petite maman... Le premier est démoniaque

Pour l'instant j'ai ça dans la catégorie "4096 avec le moins de points possible".
Edit : Et ça dans la catégorie "Le plus gros score possible".



Edit 2 : Et le plus pourri évidemment.