Intéressant, j'ai pas vraiment réussi à simplifier le problème.

J'ai fait parcourir 16.517.163 grilles à un programme pour qu'il m'en trouve une qui a la bonne somme. Mais elle n'est même pas bonne pour les autres conditions .

Mauvaise grille:

    7     0     1
  269     0     0
18671  8202  6183

Bonjour,
et bravo pour l'inventivité.

 Cliquez pour afficher

Quelques observations:
Si on touche toutes les touches 1 fois, on obtient un total
multiplié par 6 et cela à toutes les séquences.
Je n'ai pas encore 33333 mais j'ai 33154 en tapant
1  3fois
2  2fois
3 ,4,5,6,7   4 fois
8 3 fois
9 3 foi

Bonjour LittleFox,

Pour m'amuser, j'ai essayé de trouver les cases qu'il fallait actionner pour trouver ta grille (même si elle ne remplie pas les conditions), ça se fait en 16 actions :

Actions 1 à 4 : (1;3) (1;1) (1;1) (3;1)
Actions 5 à 8 : (3;2) (3;1) (3;3) (3;1)
Actions 9 à 12 : (3;1) (2;1) (3;1) (3;1)
Actions 13 à 16 : (3;3) (3;3) (3;2) (3;1)

(en fait c'est assez simple à faire, il suffit de partir à chaque fois du plus grand entier et de retrouver le nombre d'avant en résolvant une petite équation du premier degré).

Bon courage pour la suite.

(pardon pour le multi-post, je n'avais pas vu à temps que dpi avait répondu)

Bonjour dpi et merci pour ta participation,

 Cliquez pour afficher

Oui, c'est une belle remarque !

toutefois je ne suis pas sûr de comprendre ta description des cases ?

Si c'est :
(1;1) (1;1) (1;1) (1;2) (1;2) (1;3) (2;1) (2;2) (2;3) (3;0) (3;0) (3;0) (3;0) (3;2) (3;2) (3;2) (3;3) (3;3) (3;3)

Alors je tombe sur la grille suivante :

8	24	32
8	32	72
240	2072	16912

Qui donne plutôt 19400 pour somme...

Et pardon dpi, il faut remplacer mes (3;0) par des (3;1).

Bon ben je n'arrive toujours pas à simplifier le problème, pourtant j'ai l'impression qu'il y a une solution sans brute force pure.

Pour DPI, je ne suis pas d'accord avec ta remarque:

 Cliquez pour afficher

Si on part de la grille de départ (somme 1) et que l'on appuie sur 1,2,3,4,5,6,7,8,9 on a la grille:

 2  2  4
 2  4 10
 4 10 28

Dont le total est 66 ce qui n'est pas 6 fois 1.

Avec la séquence 2,1,5,6,7,8,3,4,9 j'obtiens:

 3  1  5
 8  1  1
 3  5 13

Dont le total est 40 et donc la somme dépend de la séquence.

Je me trompe?

Cet algorithme génère des grilles avec un total de 33333 de manière plutôt efficace mais jusqu'ici il n'a généré aucune grille qui ne contient pas de 0. Avoir des grilles avec tout des nombres différents semble facile.

 Cliquez pour afficher

Les grilles sont encodées dans un tuple de la façon : 1ère ligne, somme 1ère ligne, 2 ème ligne, somme 2ème ligne, 3 ème ligne, somme 3 ème ligne, somme grille.

nextGrid(m) fourni les grilles possibles depuis la grille m et comment les obtenir.
solve(end) génère une grille dont la somme est end et dont tous les chiffres sont différents et strictement positifs.

J'ai essayé d'éviter de m'attarder trop sur la même somme, c'est la raison de la liste later.

from collections import deque
N=3
N1=N+1
NN1=N*N1

def nextGrid(m):
    ans = {}
    for r in range(N):
        for c in range(N):
            x = m[r*N1+N] + m[NN1+c] - m[r*N1+c]
            m_ = list(m)
            m_[r*N1+c] += x
            m_[r*N1+N] += x
            m_[N*N1+c] += x
            m_[N*N1+N] += x
            ans[tuple(m_)] = ((r,c),m)
    return ans

def solve(end):
    start = (1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1)
    found = {start: (None,None)}
    later = deque()
    later.append(start)
    while later:
        foundTotal=set()
        toAnalyze = later
        later = deque()
        while toAnalyze:
            m = toAnalyze.popleft()
            if m[-1] in foundTotal:
                later.append(m)
                continue
            foundTotal.add(m[-1])
            if m[-1] == end:
                print(m)
                m_ = list(m[r*N1+c] for r in range(N) for c in range(N))
                if all(x>0 for x in m_) and len(set(m_)) == N*N:
                    return found,m
            ng = nextGrid(m)
            for m_ in ng:
                if m_[-1] > end or m_ in found:
                    continue
                found[m_] = ng[m_]
                toAnalyze.append(m_)
    return found, None
        
found, m = solve(33333)

LittleFox,

bravo pour tes recherches,
je te propose deux pistes (en blank si tu n'as pas envie de regarder) :

 Cliquez pour afficher

- Essaye de faire en sorte que la case que tu actionnes juste avant d'atteindre la somme 33 333 soit 0 juste avant et que ce soit la seule qui n'a pas encore été actionnée.

- Les solutions les plus nombreuses se trouvent au bout de 20 actions (en tout cas c'est ce que j'ai constaté, mais c'est purement empirique).

Ces deux contraintes avaient considérablement facilité mes recherches.

Suite

Je donne une idée de mon approche:

 Cliquez pour afficher

Nous avons assez de doigts pour appuyer sur plusieurs
touches en  même temps.
Sans utiliser les coordonnées je garde le N° d'origine.
Départ :
1 2 3 4 5 6 7 8 9 total 45
1°  On actionne  1 3 4 5 6 7 --->total  187
2° On actionne toutes les touches --->total 1122  ( 187 x6)
3° idem -->total 6732
4° On actionne  3 4 5 6 7 8 9 -->total 33154

@dpi

 Cliquez pour afficher

Je pense qu'on est obligé d'appuyer sur une case à la fois ^^

 Cliquez pour afficher

Merci pour les astuces, je vais voir ce que je peux faire avec ça .

Résolu!!!
Il était pas facile celui-là et je suis étonné par l'efficacité du résultat final alors que mes résultats intermédiaires étaient très décevant

Merci Alishisap

Défi suivant, obtenir une grille avec une somme de 1.234.567. J'en ai une en 40 coups

 Cliquez pour afficher

Au final je ne fais que parcourir les grilles dans le bon ordre .
Pour chaque grille rencontrée je génère toutes les grilles possibles à partir de celle-ci. Parmi les grilles ainsi générées je commence par celle qui a le moins de 0 et la plus proche de l'objectif. Et c'est tout . Pas de simplification mathématique ou autre.

J'obtiens la grille

    1    10 24030
  152  1259     2
 2197  5661    21

en 29 coups :
(2, 0), (1, 0), (1, 2), (1, 1), (2, 1), (0, 1), (0, 2), (2, 2), (0, 2), (0, 2), (0, 2), (0, 2), (0, 2), (0, 2), (0, 2), (0, 2), (0, 2),(2, 1), (2, 1), (2, 1), (1, 0), (1, 0), (1, 0), (1, 0), (2, 0), (2, 1), (2, 0), (1, 1), (2, 1)

Aucune garantie que ce soit le minimum de coups mais au final je ne génère que 3.056 grilles à comparer avec les 16.517.163 que j'avais généré à mon premier essai

from heapq import heappush, heappop

N=3
N1=N+1
NN1=N*N1

def nextGrid(m):
#    print("NextGrid",m)
    ans = {}
    for r in range(N):
        for c in range(N):
            x = m[r*N1+N] + m[NN1+c] - m[r*N1+c]
            if x == 0:
                continue
            m_ = list(m)
            m_[r*N1+c] += x
            m_[r*N1+N] += x
            m_[N*N1+c] += x
            m_[N*N1+N] += x
            if m[r*N1+c] == 0:
                m_[-1] -= 1
            ans[tuple(m_)] = ((r,c),m)
    return ans

def solve(end):
    start = (1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,8)
    found = {start: (None,None)}
    toAnalyze = [(start[-1], end-start[-2],start)]
    while toAnalyze:
        c,s,m = heappop(toAnalyze)
        if m[-2] == end:
            print(m)
            if c == 0:
                m_ = list(m[r*N1+c] for r in range(N) for c in range(N))
                if len(set(m_)) == N*N:
                    return found,m
        ng = nextGrid(m)
        for m_ in ng:
            if m_[-2] > end or m_ in found:
                continue
            found[m_] = ng[m_]
            heappush(toAnalyze, (m_[-1],end-m_[-2],m_))
    return found, None

def getSequence(found,m):
    S = []
    while found[m][0] != None:
        c,m = found[m]
        S.append(c)
    return S[::-1]

found,m = solve(33333)
S = getSequence(found,m)
print(len(S),S)

LittleFox :

 Cliquez pour afficher

Bravo à toi !! Je valide ta solution en 29 coups.

Si tu veux encore t'amuser à optimiser, j'ai trouvé personnellement plusieurs solutions en 18 coups pour 33333. Je ne sais pas si c'est l'optimum mais j'ai jamais trouvé mieux (j'attends encore un peu avant de révéler mes solutions).

Et pour 1234567, j'ai pas encore fait tourné mon programme longtemps mais il m'en a trouvé une en 29 coups :

(3;1) (2;1) (2;2) (2;2) (2;1) (2;3) (3;3) (1;1) (1;3) (3;3) (3;1) (1;3) (2;1) (2;3) (3;3) (1;3) (2;3) (3;3) (3;2) (2;1) (2;3) (1;2) (3;2) (3;2) (1;1) (1;1) (2;2) (3;2) (2;2) (3;2) (3;3) (1;2)

Qui donne :

60459	12221	2305
5469	731934	27347
138	384943	9751

LittleFox, mise à jour :

 Cliquez pour afficher

J'en ai une (péniblement) en 27 mouvements pour la somme 1234567 :

(1;2) (2;2) (2;2) (3;1) (3;2) (3;2) (3;1) (1;1) (3;1) (3;3) (1;3) (2;3) (2;3) (2;1) (1;1) (2;1) (2;3) (1;1) (2;3) (1;1) (2;1) (1;1) (1;1) (2;1) (2;2) (1;3) (2;2) (2;3)

146324	1	158540
220457	697161	11910
72	15	87

Alishisap

En suivant tes solutions je n'obtiens pas les même grilles finales. Elles sont proches mais pas les même. Du coup la somme n'est pas bonne (mais la même pour les deux solutions)

 Cliquez pour afficher

Pour ta solution en 29 coups j'obtiens la grille

  60459 2343070    2305
   5469  731934   27347
    138 1523930 1573222

Somme : 2322722

Pour celle en 27 coups:

 146324       1  158540
 220457  697161 1100065
     72      15      87

Somme : 2322722

Edit : J'obtiens les bonnes réponse en ne faisant pas les 3 derniers coups de ta première solution et en ne faisant pas le dernier coup de ta seconde. Erreur de recopiage?

Oui, je viens de vérifier pour la solution (soit-disant) en 27 mouvements, tu as raison, étrange... Pourtant j'ai recopié ce que m'a dit mon programme.

Bon tant mieux, du coup j'ai encore amélioré : 26 coups !

Non, non, 27 coups. Tu m'en avais donné 28 .

Bon, je n'arrive pas à de telles performances que les tiennes.
Je m'arrête là .

Comment est-ce que tu fais?

Oui exact, non seulement je me trompe dans l'affichage mais en plus je ne sais pas compter, je cumule.

J'attends un peu avant de donner ma solution, mais rien de glorieux je t'assure, la tienne est bien plus sophistiquée. Un indice :

 Cliquez pour afficher

C'est tout à base d'aléatoire...