Bonjour,
Après avoir un peu galéré, j'ai trouvé pour un carré de côté 3

Pour 3x3 il ne faut surtout pas essayer  9 cavaliers....

 Cliquez pour afficher

Bien vu pour 3X3 et ce n'est pas la peine d'essayer pour 4X4 car ...

Imod

Les quadrillages de côtés 2, 3+6k et 5+6k sont faisable.

┌╴┌─┐		┌╴┌╴┌─┐		┌╴┌╴┌╴┌╴┌─┐
└╴ ╶┐		└╴└╴┌─┐		└╴└╴└╴└╴┌─┐
└─┘╶┘		└─┘╶┐╶┐		└─┘╶┼─┼╴┌─┐
		└─┘╶┘╶┘		└─┘╶┼─┼╴┌─┐
				└─┘╶┐╶┐╶┐╶┐
				└─┘╶┘╶┘╶┘╶┘

┌╴┌╴┌╴┌╴┌╴┌╴┌╴┌╴┌─┐	┌╴┌╴┌╴┌╴┌╴┌╴┌╴┌╴┌╴┌╴┌─┐
└╴└╴└╴└╴└╴└╴└╴└╴┌─┐	└╴└╴└╴└╴└╴└╴└╴└╴└╴└╴┌─┐
└─┘╶┼─┼─┼─┼─┼─┼╴┌─┐	└─┘╶┼─┼─┼─┼─┼─┼─┼─┼╴┌─┐
└─┘╶┼╴┌╴┌╴┌─┐╶┼╴┌─┐	└─┘╶┼╴┌╴┌╴┌╴┌╴┌─┐╶┼╴┌─┐
└─┘╶┼╴└╴└╴┌─┐╶┼╴┌─┐	└─┘╶┼╴└╴└╴└╴└╴┌─┐╶┼╴┌─┐
└─┘╶┼╴└─┘╶┐╶┐╶┼╴┌─┐	└─┘╶┼╴└─┘╶┼─┼╴┌─┐╶┼╴┌─┐
└─┘╶┼╴└─┘╶┘╶┘╶┼╴┌─┐	└─┘╶┼╴└─┘╶┼─┼╴┌─┐╶┼╴┌─┐
└─┘╶┼─┼─┼─┼─┼─┼╴┌─┐	└─┘╶┼╴└─┘╶┐╶┐╶┐╶┐╶┼╴┌─┐
└─┘╶┐╶┐╶┐╶┐╶┐╶┐╶┐╶┐	└─┘╶┼╴└─┘╶┘╶┘╶┘╶┘╶┼╴┌─┐
└─┘╶┘╶┘╶┘╶┘╶┘╶┘╶┘╶┘	└─┘╶┼─┼─┼─┼─┼─┼─┼─┼╴┌─┐
			└─┘╶┐╶┐╶┐╶┐╶┐╶┐╶┐╶┐╶┐╶┐
			└─┘╶┘╶┘╶┘╶┘╶┘╶┘╶┘╶┘╶┘╶┘

La figure de dpi est plus sympa que la mienne
OK pour 4x4

Pour un carré de côté 6 par exemple , la disposition des agrafes sur le pourtour est unique aux symétries près . Ensuite il y a un problème dans les angles du carré restant .
Imod

En effet , il reste un carré 4X4 dont seuls les segments intérieurs doivent être recouverts par les agrafes : c'est un problème dans le problème
Imod

Pour les carrés j'avais trouvé :
soit n x n la définition du carré enveloppe soit n=2-->4 petits carrés
le nombre de segments  à couvrir est n(2n+2)
exemple 3x3---> 3(8)=24  multiple de 3 donc possible
mais 4x4--->4(10)=40 non multiple de 3 donc inutile de chercher.
et par exemple 5x5-->5(12) =60 multiple de 3 donc possible.

2n(n+1) multiple de 3 est une condition nécessaire mais pas suffisante pour trouver une couverture.
Pour n =6, on ne peut pas en trouver.

@Sylvieg
Je ne vois pas comment tu fais la bande intérieur pour n=6. Pour moi elle est  déjà impossible avant même d'être coincé pour les 4 carrés intérieurs.

Je me suis inspirée de ce que tu as trouvé pour n = 5, 9 et 11.
Même si j'ai eu un peu de mal à comprendre tes figures

Il faut voir pourquoi n ne peut pas être pair s'il est différent de 2 .
Imod

En couleurs on voit mieux le shema  qui va bien
on distingue 4 L

Quand n est pair , une fois supprimée la première couche on doit recouvrir avec des agrafes une configuration de ce genre :



On devrait voir qu'on ne peut certainement pas faire le tour de la figure

Imod

Bon, j'ai essayé d'utiliser des caractères spéciaux pour représenter les agrafes mais apparemment c'est très fragile (ça ne s'affiche pas correctement sur tous les écrans) et ce n'est pas très clair de toute façon.

Je propose une notation simplifiée: '>', 'v', '<' et '^' pour une agrafe ouverte respectivement à gauche, en haut, à droite et en bas. Plus 'x' pour une case sans agrafe.

Connaissant la case à gauche et celle en bas, on a que 4 possibilités pour la case courante:
- Soit la case courante est déjà fermée à gauche ('>', 'v', '^') et en bas ('^', '>', '<'): La case courante n'a pas d'agrafe ('x').
- Soit elle est déjà ouverte à gauche ('x', '<') et en bas ('x', 'v'): La case courante a une agrafe ouverte en haut ('v') ou à droite ('<').
- Soit elle est déjà fermée à gauche mais ouverte en bas: La case courante a une agrafe ouverte à gauche ('>')
- Soit elle est déjà ouverte à gauche mais ferméé en bas: La case courante a une agrafe ouverte en bas ('^')

On peut évidemment faire tourner ces possibilités dans les 4 directions.

Pour faire la bordure, d'un rectangle on a une seule possibilité (et sa symétrie par la diagonale):

<<.<^
v   ^
.   .
v   ^
v>.>>

<^
v>

<<<<.<<<^
vxvx.xvx^
v>x   x<^
vx     x^
..     ..
vx     x^
v>x   x<^
vx^x.x^x^
v>>>.>>>>

<<^     <<<<^
vx^     vxvx^
v>>     v>x<^
        vx^x^
        v>>>>

<<<<<<<<^        v>>>>>>>>        <<<<<<<<^
vxvxvxvx^        vx^x^x^x^        vxvxvxvx^
v>x^x^x<^        v>xvxvx<^        v>x<v>x<^
vx<<<^>x^        vx<^>>>x^        vx^xvx^x^
v>xvx^x<^        v>x^xvx<^        v>>>x<<<^
vx<v>>>x^        vx<<<v>x^        vxvx^xvx^
v>xvxvx<^        v>x^x^x<^        v>x<^>x<^
vx^x^x^x^        vxvxvxvx^        vx^x^x^x^
v>>>>>>>>        <<<<<<<<^        v>>>>>>>>

<<<<<<<<.
vxvxvxvx.
v>x^x^x..
vx<
v>x
vx<
v>x
vx.
v..

<<      <<<<<      <<<<<<<<<
vx      vxvxv      vxvxvxvxv
        v>x<v      v>x<v>x<v
        vx^xv      vx^xvx^xv
        v>>>x      v>>>x<<<v
                   vxvx^xvxv
                   v>x<^>x<v
                   vx^x^x^xv
                   v>>>>>>>x

Même si le résultat semble établi : le recouvrement est possible si et seulement si n-1 est premier avec 6 , les constructions proposées restent complexes
Imod

Edit : n est égal à 2 ou n-1 est divisible par 2 mais pas par 3
Imod

Oui, c'est plutôt ça. Moi j'ai n=2, 6k+3 ou 6k+5.

On peut passer d'une configuration n à une configuration n+6 en mettant une bordure de largeur 3 autour.

C'est donc une condition nécessaire et suffisante.

Voici une configuration pour n=11 et n=15 utilisant la bordure et une configuration pour n=17 utilisant la fractale:

<<<<<<<<<<^     <<<<<<<<<<<<<<^     <<<<<<<<<<<<<<<<^
vxvxvxvxvx^     vxvxvxvxvxvxvx^     vxvxvxvxvxvxvxvx^
v>x^x^x^x<^     v>x^x^x^x^x^x<^     v>x<v>x<v>x<v>x<^
vx<<<<<^>x^     vx<<<<<<<<<<>x^     vx^xvx^xvx^xvx^x^
v>xvxvx^x<^     v>xvxvxvxvxvx<^     v>>>x<<<v>>>x<<<^
vx<v>x<^>x^     vx<v>x<v>x<v>x^     vxvx^xvxvxvx^xvx^
v>xvx^x^x<^     v>xvx^xvx^xvx<^     v>x<^>x<v>x<^>x<^
vx<v>>>>>x^     vx<v>>>x<<<v>x^     vx^x^x^xvx^x^x^x^
v>xvxvxvx<^     v>xvxvx^xvxvx<^     v>>>>>>>x<<<<<<<^
vx^x^x^x^x^     vx<v>x<^>x<v>x^     vxvxvxvx^xvxvxvx^
v>>>>>>>>>>     v>xvx^x^x^xvx<^     v>x<v>x<^>x<v>x<^
                vx<v>>>>>>>x>x^     vx^xvx^x^x^xvx^x^
                v>xvxvxvxvxvx<^     v>>>x<<<^>>>x<<<^
                vx^x^x^x^x^x^x^     vxvx^xvx^xvx^xvx^
                v>>>>>>>>>>>>>>     v>x<^>x<^>x<^>x<^
                                    vx^x^x^x^x^x^x^x^
                                    v>>>>>>>^>>>>>>>>

J'ai dessiné "à la main" la configuration pour n = 11 en utilisant des agrafes et des o pour les cases sans agrafe.
Et je me retrouve avec un tableau de Vasarely

Toutes mes configurations sont à la main pour l'instant.
Je suis en train d'écrire un programme car je ne trouve pas de solution non carrée à la main. Et ce n'est pas clair de pourquoi ça ne marche pas

>Sylvieg ,je te conseille ma méthode sur Excel:
Tu fais 1 U que tu copies en 4 (rotation 90)
tu leur affectes une couleur puis tu les dupliques autant que nécessaire. cf 10h34
Reste à trouver les bonnes combinaisons

Voici mon programme, il trouve effectivement 3 solutions pour n=9.
Il en trouve 18 pour n=11 que je dois encore analyser

Et il en trouve 18 pour (m,n) = (15,9) le plus petit rectangle non carré recouvrable Pas encore vérifié à la main qu'il était valide mais j'ai confiance

< < < < < < < < < < < < < < ^
v x v x v x v x v x v x v x ^
v > x ^ x ^ x ^ x ^ x ^ x < ^
v x < ^ > > > > > > > > > x ^
v > x ^ x v x v x v x v x < ^
v x < < < v > x ^ x < v > x ^
v > x v x v x < ^ > x v x < ^
v x ^ x ^ x ^ x ^ x ^ x ^ x ^
v > > > > > > > > > > > > > >

 Cliquez pour afficher

from typing import Iterable

import numpy
from numpy.typing import NDArray

STAPLES = ' ^>v<x'
N_STAPLES = len(STAPLES)
UNKNOWN, UP, RIGHT, DOWN, LEFT, NONE = range(N_STAPLES)


def to_string(staples: NDArray['u8']) -> str:
    return '\n'.join(' '.join(STAPLES[value] for value in row) for row in staples)


def prefill(staples: NDArray['u8']):
    if staples.shape == (2, 2):
        staples[:, :] = numpy.array([[LEFT, UP], [DOWN, RIGHT]], dtype='u8')
        return

    height, width = staples.shape
    if height < 3 or width < 3 or height % 2 != 1 or width % 2 != 1:
        raise ValueError(f"No prefill possible for dimensions {staples.shape}.")

    staples[0, :~0] = LEFT
    staples[~0, 1:] = RIGHT
    staples[1:, 0] = DOWN
    staples[:~0, ~0] = UP

    if height == 3 or width == 3:
        return

    staples[1, 1:~0] = NONE
    staples[1, 2:~0:2] = DOWN
    staples[~1, 1:~0] = NONE
    staples[~1, 2:~0:2] = UP
    staples[1:~0, 1] = NONE
    staples[2:~0:2, 1] = RIGHT
    staples[1:~0, ~1] = NONE
    staples[2:~0:2, ~1] = LEFT


def is_valid(staples: NDArray['u8'], row, col) -> bool:
    staple = staples[row, col]
    if staple == UNKNOWN:
        return True
    return (
            (
                    row == 0
                    or staples[row - 1, col] == UNKNOWN
                    or (staple in (NONE, DOWN)) != (staples[row - 1, col] in (NONE, UP))
            )
            and (
                    col == 0
                    or staples[row, col - 1] == UNKNOWN
                    or (staple in (NONE, RIGHT)) != (staples[row, col - 1] in (NONE, LEFT))
            )
            and (
                    row + 1 == staples.shape[0]
                    or staples[row + 1, col] == UNKNOWN
                    or (staple in (NONE, UP)) != (staples[row + 1, col] in (NONE, DOWN))
            )
            and (
                    col + 1 == staples.shape[1]
                    or staples[row, col + 1] == UNKNOWN
                    or (staple in (NONE, LEFT)) != (staples[row, col + 1] in (NONE, RIGHT))
            )
    )


def validate(staples: NDArray['u8']):
    for row in range(staples.shape[0]):
        for col in range(staples.shape[1]):
            if not is_valid(staples, row, col):
                raise ValueError(f"Invalid staple at position ({row}, {col})")


def solve(staples) -> Iterable[NDArray['u8']]:
    height, width = staples.shape
    if (height * (width + 1) + width * (height + 1)) % 3 != 0:
        # No way to cover the grid with staples, the number of segments is not a multiple of 3.
        return

    validate(staples)

    # Spiral from outside in
    order = []
    border_limit = min(staples.shape) // 2
    for border in range(border_limit):
        order.extend((border, col) for col in range(border, staples.shape[1] - (border + 1)))
        order.extend((row, border) for row in range(border + 1, staples.shape[0] - border))
        order.extend((staples.shape[0] - border - 1, col) for col in range(border + 1, staples.shape[1] - border))
        order.extend((row, staples.shape[1] - border - 1) for row in range(border, staples.shape[0] - (border + 1)))

    order.extend((row, col)
                 for row in range(border_limit, staples.shape[0] - border_limit)
                 for col in range(border_limit, staples.shape[1] - border_limit))

    order = [position for position in order if staples[position] == UNKNOWN]

    staples = staples.copy()
    o = 0
    while 0 <= o:
        if o >= len(order):
            yield staples
            o -= 1
            if o >= 0:
                staples[order[o]] += 1
            continue

        position = order[o]
        if staples[position] >= N_STAPLES:
            staples[position] = UNKNOWN
            o -= 1
            if o >= 0:
                staples[order[o]] += 1
            continue

        if staples[position] == UNKNOWN or not is_valid(staples, *position):
            staples[position] += 1
            continue

        o += 1


def main(width, height):
    staples: NDArray['u8'] = numpy.zeros((height, width), dtype='u8')
    prefill(staples)
    for i, solution in enumerate(solve(staples)):
        print(i)
        print(to_string(solution))


if __name__ == '__main__':
    main(15, 9)

Merci dpi,
Très bonne idée d'utiliser Excel.
Tes figures sont très parlantes.

Si je ne me trompe pas, pour le rectangle (15,9) de 17h12, les colonnes 6 et 7 sont identiques aux colonnes 12 et 13.
On retrouve le carré (9,9) de deux façons en supprimant les colonnes 6 à 11 ou 7 à 12.

Pour le carré , l'amorce d'une récurrence :


Imod

@Sylvieg
Effectivement, on peut retirer 6 colonnes pour réobtenir n=9. Bien vu

En répétant ces colonnes, on peut avoir (m=6k+3, 9) avec k aussi grand que l'on veut.

J'aime celui-ci, il a une symmétrie de 180°. Et il a un n=3 au centre:

< < < < < < < < < < < < < < ^
v x v x v x v x v x v x v x ^
v > x < v > x ^ x < v > x < ^
v x ^ x v x < < ^ x v x ^ x ^
v > > > x < v x ^ > x < < < ^
v x v x ^ x v > > x ^ x v x ^
v > x < ^ > x v x < ^ > x < ^
v x ^ x ^ x ^ x ^ x ^ x ^ x ^
v > > > > > > > > > > > > > >

2x27724 solutions pour n=15

En fait la récurrence modulo 6 est immédiate , j'ai juste retiré la couche périphérique pour un meilleure lisibilité :



Imod

Oui, oui, c'est la bordure de taille 3 🙂

<<<<<<<<.
vxvxvxvx.
v>x^x^x..
vx<
v>x
vx<
v>x
vx.
v..

Mes messages risquent d'être pas mal décalés par rapport aux interventions des uns et des autres car je n'ai quasiment pas de connexion et je profite du peu à disposition pour envoyer sans prendre vraiment le temps de lire .

Dans le cas du rectangle une des conditions est que longueur et largeur soient (0;0) ou (2;2) modulo 3 . Ce n'est bien sûr pas suffisant .

Imod

Une fois supprimées les 3 couches superficielles on doit retrouver un rectangle ayant les mêmes caractéristiques .
Imod

Une remarque à propos du rectangle "minimal" de LittleFox . C'est bien un minimum dans le sens ou ne peut pas le réduire comme un oignon en enlevant  trois couches . il y a une petite permutation sur la frontière qui brouille les choses



Imod