BATTLE 2048 : VIENDEZ VOUS FIGHTER !!!

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.

2048 en 20076 points !
(prouvable par photo envoyée par mail ou sms, ma touche impression écran marche pas , et puis flemme de m'envoyer un mail sur l'ordi ^^)

Alors là faudra que tu m'expliques comment puisqu'on a prouvé qu'il faut au moins 20480 points...

avec les "4" qui apparaissent une fois sur 2 ou presque, encore !

pour moi, ça veut dire que tu as obtenu 101 tuiles"4". ( =(20480 - 20076) /4 )

Ah nan mais l'aut'
(Si tu vas voir les tables de score, tu verras que je ne suis pas le seul à être descendu en dessous de la barre de ta "preuve", et que quelqu'un d'autre a fait le score "parfait" )

EDIT : Ma grille ne contenait pas que 2048 Tahiti bob, mais j'ai pas trop suivi votre démarche
(Au moins trois "2" et un "16").

Haaaan la compétition s'enflamme!!!

oh punaise, encore un truc démoniaque ! je viens de dégoter le 2048 en cube ! en dimension 3 donc. sauf que ya pas la représentation en 3d et donc faut faire un ptit effort au début pour comprendre comment ça marche.
http://joppi.github.io/2048-3D/

ya 3 tableaux l'un à côté de l'autre de 3x3 cases. chacune représente une tranche verticale du cube de 3x3x3 (un rubickscube quoi). à gauche, la face avant, au milieu, la tranche du mlilieu, et à droite, la tranche arrière. Et donc on controle les 3 en même temps, pour les transferts intercouches dans la 3 eme dimension, deux touches sont rajoutées, A et E (il faut bien mettre son clavier en mode anglais : Alt+Maj je crois le raccourci). Ainsi, on controle tout avec zsqd et a et e comme un roxxor gamer !

Et bonne nouvelle j'ai fait 2048 au premier coup !

je refuse d'essayer

Oui, le coup des 4... chui con ^^

ouéééé ! a y est j'ai refait un 2048 dans le jeu classique ! mon deuxieme !   
avec 20 196 points.
Et quand j'ai continué jme suis arreté à 30 596 points, j'ai décollé le 2048 et mon 1024 du coin.

oulaa j'ai un pote qui a fait un 78 800 pts les gars faut vous réveiller !

Les aspergers sont dans une catégorie à part :mrgreen:

kikoulol

Ca c'est un jeu pour les autistes =))
Peux pas aller jusqu'à 7h du matin...

Tigrou a écrit:

Joli!!!

on l'attendait celle là !

(et je suis étonné par moi même de ne pas déjà avoir cédé à faire cette blague)

L'image n'est pas de moi  

J'ai fais un essai mais j'ai déconné  


C'est long les parties

Bon on devrait pas que lui voler sa voiture moi j'dis...



Une bonne dizaine d'essais... J'pense avoir trouver mon système... Et c'est pas un escargot central =)

Le pire c'est l'effleurage de la mauvaise flèche ou le mouvement de pulpe sur une tablette... Grrrr

Tigrou a écrit:C'est long les parties

15-20 minutes par 2048 je dirais, donc un peu moins de 40 pour la 4096

Nouveau score



J'étais autour de 20 000 pour les 2048 donc je dois faire la même technique, je pense qu'il y en a qu'une de toute façon.

Bill D. a écrit: J'pense avoir trouver mon système... Et c'est pas un escargot central =)

c'est normal, l'escargot, il était envisagé uniquement pour le calcul. On aurait pu aussi prendre le serpent qui fait des S de heut en bas ça aurait été la même chose. Mais dans les faits, on peux pas jouer de cette façon. Seule la technique du coin est jouable.

Bien joué pour ces petits scores !

yo ! mon high scor tout frais sinon voila sinon j'ai un sceen avec 39920 avec 2 tuile 2048 cote a cote :p je lâche l'affaire a la tuile ultime ..



(house mon fail était potentiellement plus monstrueux que ton score fail :p )

Joli, je mets à jour le classement, je vais t'appeler "numéro 2"

1. ⓗⓞⓤⓢⓔ : 78 340 pts
2. Time Out : 75 848 pts
3. Lucas : 72 752 pts
4. Free : 51 788
5. Tahiti Bob : 28 804 pts
6. Zwizwi : 20 480 pts
7. Turlutator : 14 000 pts
8. Kalthu : 13 000?
9. Faustermax : 5 376 pts

Quel score fail sinon?

Je débute depuis ce soir seulement et déjà accro   

"Étourderie m'a tuer"
Objectif: 4096 avant la fin de semaine