Seuls les membres ayant 30 points peuvent parler sur le chat.

Forum Casio - Concours


Index du Forum » Concours » [Topique d'entraide] Le défi de Xuanwu
Hackcell Hors ligne Membre Points: 1365 Défis: 11 Message

[Topique d'entraide] Le défi de Xuanwu

Posté le 24/09/2020 18:57

Bonjours à toutes et à tous, et bienvenue sur le topique d'entraide pour le premier défi python du concours de rentrée 2020

Vous pouvez partager ici vos astuces, idées ou découverte, ou voir ce que les autres font. Rappelons tout de même que de poster directement des solutions est considéré comme de la triche et est donc interdit (du moins c'était le cas il y a deux ans et aucunes idée pur cette année )

Tout d'abord, le défi cette année semble être de guider à travers un labyrinthe une machine à coup de tourner à gauche/droite d'un angle θ et avancer. Pour avoir une participation valide, il faut compléter le labyrinthe, et pour gagner, faire ceci avec le minimum d'énergie/score (un peu de patience, j'y viens).

On a donc 3 fichiers à notre disposition:
- labytest.py qui sert à soumettre votre proposition
- polycalc.py qui permet d'uniformiser le dessin sur tous les modèles et floutant la limite entre la folie et le génie
- laby.py celui qui nous intéresse, contenant les fonctions de mouvement/calculs de score.

Maintenant que les banalités sont sous le tapis passons à la partie plus intéressante, celle ou je vous décortique le programme

Donc, il y a beaucoup de chose dans ce court fichier:
- De nombreuse fonction pour le hasard, elles servent à créer le labyrinthe afin qu'il soit généré procéduralement (mais comme tout le monde a la même seed minecraft, on a tous le même) pas grands chose à creuser de ce côté
- quelques fonctions de tracés, aucun commentaire.

Concentrons-nous à présent sur comment agir sur l'environnement:
- La foreuse est représentée par une liste de 7 nombres:
- X, Y, θ, une copie de X, une copie de Y, et score1, score2 et score3 (plus connues sous le nom state[i] dans le code)
- Les fonctions tourner vont changer θ du nombre de radian indiqué dans le sens horaire (droite) ou anti-horaire (gauche).
- La fonction avancer va effectuer des pas en avant de 0.25 (selon l'angle θ actuel).

Enfin le score:
- Le score final est calculé en faisant score1 moins la division euclidienne de score2 par deux plus le sinus de score3( score = scrore1 - score2//2 + sin(score3))
- Touner de θ augmente score1 par 5 +cout(θ) et de score3 de θ
- Avancer augmente score1 de 8+cout(l) et score3 de l
- Avancer augmente score2 de 1 par pas de 0.25, soit de 4*l au total (et donc diminue le score final de 2*l ramené à l'entier inférieur)
- Si vous rencontrez un mur, score1 augmente de 15 et la fonction s'arrête (ne vous donnant pas vos points dans score2)

La fonction cout est en fait la suivante:
def cout(a):
    return len(str(round(abs(x)/1.,5)

Donc dans l'ordre:
- abs met votre nombre a la valeur absolue
- /1. convertie ce dernier en nombre a virgule
- round ne garde que 5 chiffres après la virgule
- str transforme le tout en chaine de caractères
- len renvois la longueur de cette chaine de caractères

Ce que cela signifie, c'est que score1 augmentera du nombre de caractères dans a, mais:
- le potentiel signe moins est ignoré
- 1 est convertie en 1.0, donc niveau score c'est la même que 1.2
- les chiffres ne sont comptés que jusqu'à 5 place après la virgule

Enfin derniers détails:
- score2 ne peut pas être plus grand que 200.
- fix_angle(a) renvoi a

Et voilà, c'est tout pour moi, la stratégie semble donc de faire les plus grandes lignes droites possibles avec le minimum de virages.

Sur ce bonne chance et que la meilleure gagne ♥


1, 2 Suivante
Kikoodx Hors ligne Membre Points: 2195 Défis: 11 Message

Citer : Posté le 24/09/2020 19:00 | #


C'était rapide hehehe.
Je remet du coup.

Coucou.
Les angles utilisés par a_gauche et a_droite sont exprimés en radians.
Ajouter cette ligne après import permet de taper les fonctions plus vite sur calto (j'ai vu que c'était possible direct dans l'import mais je préfère comme ça).
g, d, a = a_gauche, a_droite, avancer

C'est très basique mais faut bien commencer quelque part.
2+2=5
Perdu
Massena Hors ligne Rédacteur Points: 1403 Défis: 11 Message

Citer : Posté le 24/09/2020 19:03 | #


Merci beaucoup Hackell ! Tu n'as fait que confirmer ce que je pensais déjà concernant la stratégie, mais merci beaucoup pour l'explication du code

Bonne chance à tous !
"Rédacteur" de Planète Casio, à votre service.
Hackcell Hors ligne Membre Points: 1365 Défis: 11 Message

Citer : Posté le 25/09/2020 08:36 | #


mis à jour pour prendre en compte les changement de la v3 du script 💜
Filoji Hors ligne Maître du Puzzle Points: 320 Défis: 16 Message

Citer : Posté le 25/09/2020 10:21 | #


Code compatible v3 J'en fait de trop ?

#cas
from math import sin, cos, asin, pi
from polycalc import *
import pygame
from pygame.locals import *

def ri(a,b):
    global s
    s = (s * 214013 + 2531011) % 4294967296
    r = (s // 65536) & 0x7fff
    return r % (b-a) + a

def mon_secret(v, b, n):
    return v & ~(b * 2**n)

def mon_xor(a, b):
    return a + b - (a & b)

def fix_angle(a):
  return a * 2 * asin(1) / pi

def ufl(r):
    global rl
    i, s = r // 3, 10 * (r % 3)
    rep = rl[i]//2**s & 1023
    if rep != r:
        rep = ufl(rep)
        rl[i] = mon_secret(rl[i], 1023, s)
        s = rep * 2**s
        rl[i] = mon_xor(rl[i], s)
    return rep

def ufm(r1, r2):
    global rl
    i, r1 = r1 // 3, 10 * (r1 % 3)
    r2 *= 2**r1
    rl[i] = mon_secret(rl[i], 1023, r1)
    rl[i] = mon_xor(rl[i], r2)

def cout(x):
    return len(str(round(abs(x)/1.,5)))

def a_gauche(a):
    global state
    state[7] += a
    state[5] += 5 + cout(a)
    state[2] -= a

def a_droite(a):
    state[7] += 2 * a
    a_gauche(-a)

def avancer(l):
    global state
    t = fix_angle(state[2])
    dx, dy = cos(t), sin(t)
    state[7] += l
    state[5] += 8 + cout(l)
    while(l > 0):
        state[3:5] = state[0:2]
        x, y = state[0] + dx/4, state[1] + dy/4
        ix, iy = int(x) - (x < 0), int(y) - (y < 0)
        drx, dry = ix - int(state[3]), iy - int(state[4])
        vw = lambda y, x: wl[y] & 2**x
        hw = lambda y, x: wl[y + laby_h] & 2**x
        wx = laby_w - 2 - min(ix, ix - drx)
        tx = drx and (ix < 0 or ix >= laby_w or vw(iy - dry, laby_w - 2 - min(ix, ix - drx)))
        ty = dry and (iy < 0 or iy >= laby_h or hw(min(iy, iy - dry), laby_w - 1 - (ix - drx)))
        t = dx <= 0 or int(x) < laby_w - 1 or int(y) < laby_h - 1
        if t and tx or ty or (drx and dry and (t and tx or ty)) or (drx and dry and (t and vw(iy, laby_w - 2 - min(ix, ix - drx)) or hw(min(iy, iy - dry), laby_w - 1 - ix))):
            state[5] += 15
            return
        l -= .25
        state[6] += (state[6] < 200)
        state[0:2] = (x, y)
        draw_line(state[3] * zx, state[4] * zy, state[0] * zx, state[1] * zy, colors[4])

laby_w, laby_h = 20, 12
s = 0xdeadbeef

rl = [(3*i + 2)*1048576 + (3*i + 1)*1024 + 3*i for i in range(laby_w*laby_h + 2//3)]
wl = [(2**(laby_w + 1) - 1) // (1 + (k < laby_h)) for k in range(2*laby_h - 1)]
cl = laby_w * laby_h
while cl > 1 - (laby_w * laby_h)//100*10:
    y = ri(0, 2*laby_h - 1)
    x = ri(0, laby_w - (y < laby_h))
    if wl[y] & 2**x:
        if y < laby_h:
            r1 = y*laby_w + x
            r2 = r1 + 1
        else:
            r1 = (y - laby_h)*laby_w + x
            r2 = r1 + laby_w
        rl1, rl2 = ufl(r1), ufl(r2)
        if rl1 != rl2 or cl <= 1:
            ufm(rl1, rl2)
            cl -= 1
            wl[y] = mon_secret(wl[y], 1, x)
for r in range(laby_w * laby_h):
    ufl(r)

#screen_w, screen_h, poly_set_pixel, poly_draw_line, poly_fill_rect, poly_clean_screen, poly_show_screen = get_infos()

ratio = 3
screen_w = 384*ratio
screen_h = 192*ratio

ds = 4
zint = 1 + (screen_w > 2*laby_w*ds)
ds += zint - 1
zx, zy = (screen_w - zint) / laby_w, (screen_h - zint) / laby_h
#get_infos, poly_set_pixel, rl, ufl, ufm = None, None, None, None, None
colors = ([0, 95, 0], [0, 0, 63], [0, 200, 0], [0, 0, 255], [255, 0, 0])

pygame.init()
pygame.mixer.quit()
pygame.display.set_caption('Concours')
fenetre = pygame.display.set_mode((screen_w,screen_h))

def draw_line(x1, y1, x2, y2, c):
    pygame.draw.line(fenetre, (c),(x1, y1), (x2, y2))
    pygame.display.update()

def clean_screen():
    fenetre.fill([255,255,255])

def fill_rect_v(x, y, w, h, c):
    pygame.draw.rect(fenetre, c, Rect(x, y, 3, 15*ratio))

def fill_rect_h(x, y, w, h, c):
    pygame.draw.rect(fenetre, c, Rect(x, y, 15*ratio+10, 3))


def aller_selon(f, affiche):
    global state
    state = [0, .5, 0, 0, .5, 0, 0, 0]
    clean_screen()
    for i in range(2):
        fill_rect_v(0, i * laby_h * zy, laby_w * zx, zint, colors[1])
        fill_rect_h(i * laby_w * zx, (not i) * zy, zint, (laby_h - 1) * zy, colors[0])
    for y in range(2*laby_h - 1):
        for z in range(laby_w - (y < laby_h)):
            if wl[y] & 2**z:
                x = laby_w - 1 - z
                if y < laby_h:
                    fill_rect_v(x * zx, y * zy, zint, zy, colors[2])
                else:
                    fill_rect_h(x * zx, (y - laby_h + 1) * zy, zx, zint, colors[3])
    f()
    boucle=False
    while not boucle and affiche:
        for event in pygame.event.get():
            if event.type==QUIT:
                boucle=True
            pygame.display.update()
    state[5] += sin(fix_angle(state[7])) - state[6] // 2
    print('Consommation : ' + str(state[5]))
    if state[0] >= laby_w:
        print('------------ GG ! -----------')
        print('info@tiplanet.org.')
    return state[5]


Ajouté le 25/09/2020 à 10:23 :
J'aime beaucoup regarder l'avancement des scores en fonction de chaque action, et je peux vous dire que c'est fort intéressant
Gloire au Flying Spaghetti Monster !!!
Dark storm En ligne Membre d'honneur Points: 11174 Défis: 176 Message

Citer : Posté le 25/09/2020 11:30 | # | Fichier joint


Histoire de vous aider un peu plus


Finir est souvent bien plus difficile que commencer. — Jack Beauregard
Lephenixnoir En ligne Administrateur Points: 18529 Défis: 142 Message

Citer : Posté le 25/09/2020 12:22 | #


T'as oublié quelques passages en haut à droite !
Bebertii Hors ligne Membre Points: 4 Défis: 0 Message

Citer : Posté le 25/09/2020 14:52 | #


Taper sur calculette c'est lourd, j'ai adapté la fonction getinfo() du script numworks pour utiliser le module tkinter et pouvoir travailler directement sur PC :
import tkinter as tk

racine = tk.Tk()
canv = tk.Canvas(racine, bg="white", height=440, width=640)
canv.pack()


def conversion(nombre):
        dictionnaire=["0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"]
        return dictionnaire[nombre//16]+dictionnaire[nombre%16]



def col3_2_rgb(c, bits, bgr):
    return c[2*bgr]//2**(8 - bits[0]) + c[1]//2**(8 - bits[1])*2**bits[0] + c[2*(not bgr)]//2**(8-bits[2])*2**(bits[0] + bits[1])
def kc16_draw_line(x1, y1, x2, y2, c):
    draw_line(int(x1), int(y1), int(x2), int(y2), col3_2_rgb(c, [5, 6, 5], 1))

def get_infos():
    global kc16_draw_line
    fnop = lambda : None
    screen_w, screen_h, color_bits, poly_set_pixel, poly_draw_line, poly_fill_rect, poly_clean_screen, need_clean, need_line, need_rect = 0, 222, [5, 6, 5], fnop, fnop, fnop, fnop, 0, 1, 1
    try:
        if chr(256)==chr(0): # KhiCAS Python compat.
            need_line = 0
            need_clean = 1
            screen_w = 320
            def poly_set_pixel(x, y, c):
                set_pixel(x, y, col3_2_rgb(c, [5,6,5], 0))
            poly_draw_line = kc16_draw_line
    except:
        pass
    if not screen_w:
        kc16_draw_line = None
        try: # KhiCAS Micropython
            import graphic
            def poly_draw_line(x1, y1, x2, y2, c):
                graphic.draw_line(int(x1), int(y1), int(x2), int(y2), col3_2_rgb(c, color_bits, 1))
            def poly_fill_rect(x1, y1, x2, y2, c):
                graphic.draw_filled_rectangle(int(x1), int(y1), int(x2), int(y2), c)
            screen_w, poly_set_pixel, need_clean, need_line, need_rect = 320, graphic.set_pixel, 1, 0, 0
        except:
            pass
    if not screen_w:
        try: # NumWorks
            print("numworks détectée")

            screen_w, need_rect = 320,    0
            def poly_set_pixel(x,y,c):
                canv.create_rectangle(2*int(x), 2*int(y), 2*(int(x)+1), 2*(int(y)+1), fill="#"+conversion(c[0])+conversion(c[1])+conversion(c[2]))    
            
            def poly_fill_rect(x, y, w, h, c):
                canv.create_rectangle(2*int(x), 2*int(y), 2*(int(x)+int(w)), 2*(int(y)+int(h)), fill="#"+conversion(c[0])+conversion(c[1])+conversion(c[2]))
        except:
            pass
    if need_line:
        def poly_draw_line(x1, y1, x2, y2, c):
            m, a1, b1, a2, b2 = 0, int(x1), int(y1), int(x2), int(y2)
            if (x2 - x1) ** 2 < (y2 - y1) ** 2:
                m, a1, a2, b1, b2 = 1, b1, b2, a1, a2
            if min(a1, a2) != a1: a1, b1, a2, b2 = a2, b2, a1, b1
            for k in range(a2 - a1 + 1):
                a, b = a1 + k, int(b1 + (b2 - b1) * k / ((a2 - a1) or 1))
                poly_set_pixel((a, b)[m], (b, a)[m], c)
    if need_rect:
        def poly_fill_rect(x, y, w, h, c):
            for k in range(h):
                poly_draw_line(x, y + k, x + w - 1, y + k, c)
    if need_clean:
        def poly_clean_screen():
            poly_fill_rect(0, 0, screen_w, screen_h, [255, 255, 255])
    return screen_w, screen_h, poly_set_pixel, poly_draw_line, poly_fill_rect, poly_clean_screen, fnop
Hackcell Hors ligne Membre Points: 1365 Défis: 11 Message

Citer : Posté le 25/09/2020 16:20 | #


Il y a beaucoup d'histoire du genre "j'ai pas le même score sur caltos que sur PC" en, ce moment.

La raison est simple, votre ordi et la calculatrice ne vont pas arrondir les flottant de la même maniére, là ou un 0.97 reste un 0.97 sur pc, votre calculatrice ni verra qu'un 0.9699999999999999999 ce qui une fois passer dans cout (qui compte le nombre de caractére et l'ajoute à votre score) augmente votre score de... beaucoup! Faites ça plusieurs fois et la différence devient enorme!!

Donc méfier vous et si vous avez une solution, dites-le
Bebertii Hors ligne Membre Points: 4 Défis: 0 Message

Citer : Posté le 25/09/2020 17:16 | #


Hackcell a écrit :
Il y a beaucoup d'histoire du genre "j'ai pas le même score sur caltos que sur PC" en, ce moment.

La raison est simple, votre ordi et la calculatrice ne vont pas arrondir les flottant de la même maniére, là ou un 0.97 reste un 0.97 sur pc, votre calculatrice ni verra qu'un 0.9699999999999999999 ce qui une fois passer dans cout (qui compte le nombre de caractére et l'ajoute à votre score) augmente votre score de... beaucoup! Faites ça plusieurs fois et la différence devient enorme!!

Donc méfier vous et si vous avez une solution, dites-le

Pour l'instant j'ai 440 sur PC et 440.94 sur calculatrice. Je dirais donc que l'écart est acceptable. Mais je ne comprends pas comment font les hiscores !
Ti64CLi Hors ligne Membre Points: 629 Défis: 65 Message

Citer : Posté le 25/09/2020 17:31 | #


Personnellement, j'ai obtenu 148 sur calculatrice et 134 sur PC, donc il y avait quand même une différence de 14, ce qui est énorme
Lephenixnoir En ligne Administrateur Points: 18529 Défis: 142 Message

Citer : Posté le 25/09/2020 17:34 | #


Euh là je suis perplexe parce que les flottants qu'on manipule sont tous en précision complète, et toutes les fonctions sont uniformément continues ; y'a absolument zéro piège de précision.
Critor En ligne Administrateur Points: 1921 Défis: 18 Message

Citer : Posté le 25/09/2020 17:38 | #


Les flottants Python des Casio/NumWorks/TI sont au standard double précision, c'est-à-dire que la précision est codée sur 53 bits.
Les résultats sont absolument identiques d'un modèle à l'autre.

Nous lions des émulateurs utilisables gratuitement.

Vous avez parfaitement le droit d'utiliser autre chose, mais c'est alors à vous de tenir compte de la différence de précision dans un sens ou dans l'autre.
Hackcell Hors ligne Membre Points: 1365 Défis: 11 Message

Citer : Posté le 25/09/2020 17:39 | #


non, c'est normal, cout(0.97) renvoi 4 sur pc et 18 sur calculatrice, soit 14 de difference. il a juste dû tomber sur un nombre similaire
Lephenixnoir En ligne Administrateur Points: 18529 Défis: 142 Message

Citer : Posté le 25/09/2020 17:40 | #


Cependant il est évident que le str() MicroPython n'a pas le comportement élégant de non-ambiguité que le Python distribué sur PC utilise. Pour l'éviter il serait malin (mais je pense que c'est un peu tard) de préférer round(x*1e5) à round(x,5) puisque les entiers sont toujours représentables exactement.
Ti64CLi Hors ligne Membre Points: 629 Défis: 65 Message

Citer : Posté le 25/09/2020 17:40 | #


Je sais bien, je ne suis pas en train de critiquer et je suis totalement d'accord avec ça.
Mais le plus bizarre étant que c'est lors d'une unique étape que mon score PC et calculatrice devient différent, et directement avec un écart de 14.
Je ne vois vraiment pas d'où ça peut venir, puisque la précision n'impacte pas, étant la même

Edit : je n'ai rien dit, je n'avais pas vu le message de Hackcell
Critor En ligne Administrateur Points: 1921 Défis: 18 Message

Citer : Posté le 25/09/2020 17:44 | #


Lephenixnoir a écrit :
Cependant il est évident que le str() MicroPython n'a pas le comportement élégant de non-ambiguité que le Python distribué sur PC utilise. Pour l'éviter il serait malin (mais je pense que c'est un peu tard) de préférer round(x*1e5) à round(x,5) puisque les entiers sont toujours représentables exactement.

Si ça te convient et qu'en prime ça arrange les candidats, je peux parfaitement l'introduire dans la v4.
Lephenixnoir En ligne Administrateur Points: 18529 Défis: 142 Message

Citer : Posté le 25/09/2020 17:46 | #


Disons que ça va modifier quelques scores, mais normalement que les améliorer. Si tu penses que c'est acceptable pour le concours, vas-y. J'avoue que j'ai toujours peur de modifier le code après le lancement... j'espère que ça ne contrariera personne sur le classement encore primitif.

Edit : Oublie pas d'enlever les 0 à la fin dans ce cas.
Filoji Hors ligne Maître du Puzzle Points: 320 Défis: 16 Message

Citer : Posté le 25/09/2020 19:05 | #


Coucou, encore moi : Pour plus de rapidité, voici :
LA V2 DE LA V3 DU PROGRAMMEJ'ai plus de voix
Il affiche maintenant le score et le "GG"
J'ai ajouté to_rad(deg) pour... transformer des degrés en radians

#cas
from math import sin, cos, asin, pi
from polycalc import *
import pygame
from pygame.locals import *

def ri(a,b):
    global s
    s = (s * 214013 + 2531011) % 4294967296
    r = (s // 65536) & 0x7fff
    return r % (b-a) + a

def mon_secret(v, b, n):
    return v & ~(b * 2**n)

def mon_xor(a, b):
    return a + b - (a & b)

def fix_angle(a):
  return a * 2 * asin(1) / pi

def ufl(r):
    global rl
    i, s = r // 3, 10 * (r % 3)
    rep = rl[i]//2**s & 1023
    if rep != r:
        rep = ufl(rep)
        rl[i] = mon_secret(rl[i], 1023, s)
        s = rep * 2**s
        rl[i] = mon_xor(rl[i], s)
    return rep

def ufm(r1, r2):
    global rl
    i, r1 = r1 // 3, 10 * (r1 % 3)
    r2 *= 2**r1
    rl[i] = mon_secret(rl[i], 1023, r1)
    rl[i] = mon_xor(rl[i], r2)

def cout(x):
    return len(str(round(abs(x)/1.,5)))

def a_gauche(a):
    global state
    state[7] += a
    state[5] += 5 + cout(a)
    state[2] -= a

def a_droite(a):
    state[7] += 2 * a
    a_gauche(-a)

def avancer(l):
    global state
    t = fix_angle(state[2])
    dx, dy = cos(t), sin(t)
    state[7] += l
    state[5] += 8 + cout(l)
    while(l > 0):
        state[3:5] = state[0:2]
        x, y = state[0] + dx/4, state[1] + dy/4
        ix, iy = int(x) - (x < 0), int(y) - (y < 0)
        drx, dry = ix - int(state[3]), iy - int(state[4])
        vw = lambda y, x: wl[y] & 2**x
        hw = lambda y, x: wl[y + laby_h] & 2**x
        wx = laby_w - 2 - min(ix, ix - drx)
        tx = drx and (ix < 0 or ix >= laby_w or vw(iy - dry, laby_w - 2 - min(ix, ix - drx)))
        ty = dry and (iy < 0 or iy >= laby_h or hw(min(iy, iy - dry), laby_w - 1 - (ix - drx)))
        t = dx <= 0 or int(x) < laby_w - 1 or int(y) < laby_h - 1
        if t and tx or ty or (drx and dry and (t and tx or ty)) or (drx and dry and (t and vw(iy, laby_w - 2 - min(ix, ix - drx)) or hw(min(iy, iy - dry), laby_w - 1 - ix))):
            state[5] += 15
            return
        l -= .25
        state[6] += (state[6] < 200)
        state[0:2] = (x, y)
        draw_line(state[3] * zx, state[4] * zy, state[0] * zx, state[1] * zy, colors[4])

laby_w, laby_h = 20, 12
s = 0xdeadbeef

rl = [(3*i + 2)*1048576 + (3*i + 1)*1024 + 3*i for i in range(laby_w*laby_h + 2//3)]
wl = [(2**(laby_w + 1) - 1) // (1 + (k < laby_h)) for k in range(2*laby_h - 1)]
cl = laby_w * laby_h
while cl > 1 - (laby_w * laby_h)//100*10:
    y = ri(0, 2*laby_h - 1)
    x = ri(0, laby_w - (y < laby_h))
    if wl[y] & 2**x:
        if y < laby_h:
            r1 = y*laby_w + x
            r2 = r1 + 1
        else:
            r1 = (y - laby_h)*laby_w + x
            r2 = r1 + laby_w
        rl1, rl2 = ufl(r1), ufl(r2)
        if rl1 != rl2 or cl <= 1:
            ufm(rl1, rl2)
            cl -= 1
            wl[y] = mon_secret(wl[y], 1, x)
for r in range(laby_w * laby_h):
    ufl(r)

#screen_w, screen_h, poly_set_pixel, poly_draw_line, poly_fill_rect, poly_clean_screen, poly_show_screen = get_infos()

ratio = 2
screen_w = 384*ratio
screen_h = 192*ratio

ds = 4
zint = 1 + (screen_w > 2*laby_w*ds)
ds += zint - 1
zx, zy = (screen_w - zint) / laby_w, (screen_h - zint) / laby_h
#get_infos, poly_set_pixel, rl, ufl, ufm = None, None, None, None, None
colors = ([0, 95, 0], [0, 0, 63], [0, 200, 0], [0, 0, 255], [255, 0, 0])

pygame.init()
pygame.mixer.quit()
pygame.display.set_caption('Concours')
fenetre = pygame.display.set_mode((screen_w,screen_h+12*ratio))
font = pygame.font.Font('freesansbold.ttf', 22)

def draw_line(x1, y1, x2, y2, c):
    pygame.draw.line(fenetre, (c),(x1, y1), (x2, y2))
    pygame.display.update()

def clean_screen():
    fenetre.fill([255,255,255])

def fill_rect_v(x, y, w, h, c):
    pygame.draw.rect(fenetre, c, Rect(x, y, 3, 15*ratio))

def fill_rect_h(x, y, w, h, c):
    pygame.draw.rect(fenetre, c, Rect(x, y, 15*ratio+10, 3))


def aller_selon(f, affiche):
    global state
    state = [0, .5, 0, 0, .5, 0, 0, 0]
    clean_screen()
    for i in range(2):
        fill_rect_v(0, i * laby_h * zy, laby_w * zx, zint, colors[1])
        fill_rect_h(i * laby_w * zx, (not i) * zy, zint, (laby_h - 1) * zy, colors[0])
    for y in range(2*laby_h - 1):
        for z in range(laby_w - (y < laby_h)):
            if wl[y] & 2**z:
                x = laby_w - 1 - z
                if y < laby_h:
                    fill_rect_v(x * zx, y * zy, zint, zy, colors[2])
                else:
                    fill_rect_h(x * zx, (y - laby_h + 1) * zy, zx, zint, colors[3])
    f()
    state[5] += sin(fix_angle(state[7])) - state[6] // 2
    print('Consommation : ' + str(state[5]))
    if state[0] >= laby_w:
        print('------------ GG ! -----------')
        print('info@tiplanet.org.')
        gg = font.render('GG', True, (128,0,0), (255,255,255))
        ggrect = gg.get_rect()
        fenetre.blit(gg, (384*ratio-50, 192*ratio + 1))
    text = font.render('C:' + str(state[5]), True, (0,0,0), (255,255,255))
    textRect = text.get_rect()
    fenetre.blit(text, (0, 192*ratio + 1))
    boucle=False
    while not boucle and affiche:
        for event in pygame.event.get():
            if event.type==QUIT:
                boucle=True
            pygame.display.update()
    return state[5]

def to_rad(deg):
    return deg*pi/180

Gloire au Flying Spaghetti Monster !!!
Bebertii Hors ligne Membre Points: 4 Défis: 0 Message

Citer : Posté le 25/09/2020 19:42 | #


Ti64CLi a écrit :
Personnellement, j'ai obtenu 148 sur calculatrice et 134 sur PC, donc il y avait quand même une différence de 14, ce qui est énorme
Oo'
Je suis descendu à 211, toujours pas d'écart
Dark storm En ligne Membre d'honneur Points: 11174 Défis: 176 Message

Citer : Posté le 25/09/2020 23:48 | #


Je veux pas balancer, mais Pavel a fait un script qui aide grandement à la résolution du problème


Finir est souvent bien plus difficile que commencer. — Jack Beauregard
1, 2 Suivante

LienAjouter une imageAjouter une vidéoAjouter un lien vers un profilAjouter du codeCiterAjouter un spoiler(texte affichable/masquable par un clic)Ajouter une barre de progressionItaliqueGrasSoulignéAfficher du texte barréCentréJustifiéPlus petitPlus grandPlus de smileys !
Cliquez pour épingler Cliquez pour détacher Cliquez pour fermer
Alignement de l'image: Redimensionnement de l'image (en pixel):
Afficher la liste des membres
Pour coloriser votre code, cliquez ici.
Sinon cliquez sur le bouton ci-dessous.
:bow: :cool: :good: :love: ^^
:omg: :fusil: :aie: :argh: :mdr:
:boulet2: :thx: :champ: :whistle: :bounce:
valider
 :)  ;)  :D  :p
 :lol:  8)  :(  :@
 0_0  :oops:  :grr:  :E
 :O  :sry:  :mmm:  :waza:
 :'(  :here:  ^^  >:)

Σ π θ ± α β γ δ Δ σ λ
Veuillez donner la réponse en chiffre
Vous devez activer le Javascript dans votre navigateur pour pouvoir valider ce formulaire.

Si vous n'avez pas volontairement désactivé cette fonctionnalité de votre navigateur, il s'agit probablement d'un bug : contactez l'équipe de Planète Casio.

Planète Casio v42 © créé par Neuronix et Muelsaco 2004 - 2020 | Il y a 83 connectés | Nous contacter | Qui sommes-nous ? | Licences et remerciements

Planète Casio est un site communautaire non affilié à Casio. Toute reproduction de Planète Casio, même partielle, est interdite.
Les programmes et autres publications présentes sur Planète Casio restent la propriété de leurs auteurs et peuvent être soumis à des licences ou copyrights.
CASIO est une marque déposée par CASIO Computer Co., Ltd