Forum Liberty Basic France

Le 14/12/2018 à 21h08

Libertynaute Débutant

Groupe: Membre

Inscrit le: 10/10/2012
Messages: 19
Bonsoir,
Y'a t'il un ordre qui permette d'effectuer un tri en just basic.
Par exemple je crée une dim(100) que je nomme ZONE,dans laquelle je rentre 100 nombre entre 1 et 100,puis je demande a les trier en ordre croissant ou decroissant.
J'ai trouvé "SORT" en liberty basic,mais rien en justbasic ..Peut etre que cela n'existe pas...!?
Merci A+++

Web    
Le 15/12/2018 à 00h52

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2095
Pour trier des nombres y a ça: (laisse lui le temps de trier)
Code VB :
 
 nomainwin
    WindowWidth = 455
    WindowHeight = 500
    UpperLeftX = 100
    UpperLeftY = 10
    TEXTBOX #t.n,  10, 10, 40, 25
    BUTTON #t.go, " Go !", [go], UL, 150, 10, 40, 25
    BUTTON #t.tri, " TRI !", [tri], UL, 240, 10, 40, 25
   TEXTEDITOR #t.tab, 10, 50, 200, 380
   TEXTEDITOR #t.trib, 230, 50, 200, 380
    GRAPHICBOX #t.m 5, 5, 440, 435
    OPEN "Tri disques" FOR window_nf AS #t
    #t, "TRAPCLOSE [closetri]"
    #t.m , "down"
    #t.m , "fill darkblue"
    #t.m , "color yellow; backcolor darkblue"
    #t.m , "PLACE 60, 20": #t.m, "\ <---N"
    n=100
    #t.n, str$(n)
   diam$=" 5 10 15 20 25 30 35 40 45 50"
   wait
   for x=1 to n
   next x
  wait
  [go]
    #t.n, "!contents? var$": n=val(var$)
    dim bubble(n)
    for x=1 to n
    alea= int(rnd(1)*10) + 1
      bubble(x)=val(word$(diam$,alea))
    next x
      '-----------
    for x=1 to n
      #t.tab, bubble(x)
    next x
  wait
  [tri]
FOR i=1 TO n
    FOR j=1 TO (n-1)
        IF bubble(j) > bubble(j+1) THEN
            temp=bubble(j)
            bubble(j)=bubble(j+1)
            bubble(j+1)=temp
        END IF
        #t.trib, str$(bubble(i))
    NEXT j
NEXT i
  #t.trib, "!cls"
    for x=1 to n
      #t.trib, bubble(x)
    next x
wait
  wait
  [closetri]
    close #t
  end
 
____________________
Roro

   
Le 15/12/2018 à 13h10

Libertynaute Débutant

Groupe: Membre

Inscrit le: 10/10/2012
Messages: 19
Merci roland pour mon cadeau de noel,j'ai du pain sur la planche ...
Par contre je ne savais pas que l'on pouvais emboiter 2 for-next
Aujourd'hui je serai plus intelligent..ou moins idiot
A ++++

Web    
Le 15/12/2018 à 16h48

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2095
Citation:
je ne savais pas que l'on pouvais emboiter 2 for-next

Plus on emboite de "for next" et plus ça devient moins facile et plus les temps de traitement s'allongent.
____________________
Roro

   
Le 15/12/2018 à 23h43

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 522
En toute logique, je suppose ;)

Bonsoir du samedi,

A titre de piste, voici une source d'inspiration. J'avoue ne pas avoir regardé le code de Roland, et m'être lancé tête baissée dans la programmation d'un tri qui s'est avérée plus longue que prévu à mettre au point. Mais à un moment donné, tout s'est éclairci, et voici le résultat :
Code VB :
 
'voici la série de nombre qu'on voudrait trier
[N] data 1,5,2,14,9,-9,12,3,9,-4,2
 
'pour cela, j'ai utilisé un tableau dit multi-dimensionnel
'mais on peut tout autant utiliser trois tableaux distincts
nbdat=11
dim table(nbdat,2)' contiendra les données :
    '(nbdat,0)  ->  dans l'ordre de lecture de la ligne de data
    '(nbdat,1)  ->  triées par ordre numérique
    '(nbdat,2)  ->  (pour gestion du tri)

'mise en tableau des données dans l'ordre de lecture des datas
restore [N]
for a=0 to nbdat-1
    read b
    table(a,0)=b
next
 
'tri
'on cherche à savoir combien d'éléments du tableau sont inférieurs à
'l'élément courant : la nouvelle position de l'élément courant sera
'à "quantité d'éléments inférieurs à l'élément courant" + 1

endessous=0
for i=0 to nbdat-1
 
    'comparaison de l'élément courant avec les autres éléments
    elemcour=table(i,0) '->l'élément courant
    endessous=0         'quantité d'éléments inférieurs à l'élément courant
    for j=0 to nbdat-1
        if elemcour>table(j,0) then endessous=endessous+1
    next
 
    'placer l'élément courant à sa nouvelle position
    'et signaler qu'il a été traité, et qu'il ne faut plus le reprendre
    table(endessous,1)=elemcour
    table(i,2)=1
 
    'il peut y avoir des éléments identiques à l'élément courant, qu'il faut prendre
    'en compte, et ajouer dans les cases directement sous l'élément courant

    'recherche des éléments identiques
    tour=0
    for k=0 to nbdat-1
        'on ne traite l'élément courant que s'il n'a pas été déjà traité
        if elemcour=table(k,0) and table(k,2)=0 then
            endessous=endessous+1
            table(endessous,1)=elemcour
            table(k,2)=1
            tour=tour+1 'donne le nombre de fois où l'élément se répète
        end if
    next
next
 
' tri terminé, on affiche la liste de nombres telle qu'elle apparaissait
'dans la ligne de datas, et la même liste une fois triée
print "case,   ordre initial,   ordre trié."
for a=0 to nbdat-1
    print a;",   ";table(a,0);",   ";table(a,1)
next
 


A noter que la variable "tour" ne sert à rien, j'ai oublié de la retirer



Edité par Christophe Le 15/12/2018 à 23h46
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia6 + Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 16/12/2018 à 01h01

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2095
Pas mal, y a plus qu'à retirer les doublons (une piste: Remplacer les doublons par des chaines vides faciles à repérer et à supprimer)
____________________
Roro

   
Le 16/12/2018 à 08h40

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 522
Merci ;)

J'ai aussi pensé à retirer les doublons, mais on ne sait pas quel usage sera fait des données triées, ni si elles seront liées à d'autres informations, donc autant les conserver toutes.

Je verrais bien ce retrait de doublons sous la forme d'un nouveau tableau, qui ne prendrait qu'un exemplaire de chaque valeurs et qu'on afficherait à l'écran, par exemple, tout en conservant intactes les données initiales et triées.
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia6 + Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 16/12/2018 à 15h03

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2095
Citation:
en conservant intactes les données initiales et triées.

Tout à fait, d'où la présence de plusieurs texteditors.
Pour trier les doublons, j'ai associer un code anglophone de tris alpha numérique (chaines) sans doublons au code précédent (qui est aussi anglophone).
Mais comme il a un os à l'arrivée, je renvoie le résultat final au tri en repassant en numérique, ce qui renvoi le résultat dans le texteditor du milieu.pourquoi faire simple quand on peut faire compliqué.
ça a l'air de marcher.
Code VB :
 
    nomainwin
    WindowWidth = 675 '455
    WindowHeight = 500
    UpperLeftX = 100
    UpperLeftY = 10
    TEXTBOX #t.n,  10, 10, 40, 25
    BUTTON #t.go, " Go !", [go], UL, 150, 10, 40, 25
   TEXTEDITOR #t.tab, 10, 50, 200, 380
   BUTTON #t.tri, " Tri !", [tri], UL, 240, 10, 40, 25
   TEXTEDITOR #t.trib, 230, 50, 200, 380
   BUTTON #t.doub, " Sans doublons", [doub], UL, 510, 10, 80, 25
   TEXTEDITOR #t.dobl, 450, 50, 200, 380
    GRAPHICBOX #t.m 5, 5, 655, 435
    OPEN "Tri disques" FOR window_nf AS #t
    #t, "TRAPCLOSE [closetri]"
    #t.m , "down"
    #t.m , "fill darkblue"
    #t.m , "color yellow; backcolor darkblue"
    #t.m , "PLACE 60, 20": #t.m, "\ <---N"
    n=50
    #t.n, str$(n)
   diam$=" 5 10 15 20 25 30 35 40 45 50"
   wait
   for x=1 to n
   next x
  wait
  [go]
    #t.n, "!contents? var$": n=val(var$)
    dim bubble(n)
    for x=1 to n
    alea= int(rnd(1)*10) + 1
      bubble(x)=val(word$(diam$,alea))
    next x
      '-----------
    for x=1 to n
      #t.tab, bubble(x)
    next x
  wait
  [tri]
FOR i=1 TO n
    FOR j=1 TO (n-1)
        IF bubble(j) > bubble(j+1) THEN
            temp=bubble(j)
            bubble(j)=bubble(j+1)
            bubble(j+1)=temp
        END IF
        #t.trib, str$(bubble(i))
    NEXT j
NEXT i
  #t.trib, "!cls"
    for x=1 to n
      #t.trib, bubble(x)
    next x
wait
  wait
  [closetri]
    close #t
  end
'-------------------------------doubles-----------------
[doub]
  nbmots=n
dim liste$(nbmots):dim tri$(nbmots)
for a=1 to nbmots-1
    liste$(a)=str$(bubble(a))
next
for ref=1 to nbmots-1
    motRef$=liste$(ref)
    for compare=1 to nbmots-1
        if ref<>compare then
            motCompare$=liste$(compare)
            'si les mots sont différents
            if motRef$<>motCompare$ then
                'on compare lettre à lettre le mot référence et le mot comparé
                lettre=1
                difference=0
                while difference=0
                    'codes ascii des lettres
                    a=asc(mid$(motRef$,lettre,1))
                   b=asc(mid$(motCompare$,lettre,1))
                   '''''on supprime la distinction majuscules-minuscules
                    if a>96 then a=a-32
                   'if b>96 then b=b-32
                   ''' 'pour quitter l'analyse lorsque les lettres seront différentes
                    if a=b then lettre=lettre+1 else difference=1
                wend
                if a>b then apres=apres+1 else avant=avant+1
            end if
        end if
    next
    tri$(apres)=motRef$ 'tri dans l'ordre conventionnel
    'tri$(avant)=motRef$ 'tri dans l'ordre inverse
    avant=0:apres=0
next
'suppression des cases vides
'comptage des cases vides pour dimensionner le tableau définitif
for a=1 to nbmots-1
    if tri$(a)="" then casevide=casevide+1
next
nbcases=nbmots-casevide
dim definitif$(nbcases+10)
'transfert des cases non vides dans le tableau définitif
actuel=1
for a=1 to nbmots-1
    if tri$(a)<>"" then
       definitif$(actuel)=tri$(a)
       actuel=actuel+1
    end if
next
for a=1 to nbcases: #t.dobl, definitif$(a): next a
redim bubble(nbcases+1)
    for x=1 to nbcases
      bubble(x)=val(definitif$(x))
    next x
    n=nbcases
   goto [tri]
wait
 
____________________
Roro

   
Le 16/12/2018 à 23h30

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 522
Hi 3 fois, comme disent les amateurs de radio, est-tu sûr que la seconde partie de ton code est adaptée de chez les Grands-Bretons ? Ou est-ce un appel du pied pour que je reprenne les travaux sur la base de données ;) Farceur !

Citation:
Mais comme il a un os à l'arrivée

J'ai constaté l'os, mais je n'ai pas trouvé d'où il pouvait venir. Je subodore une facétie de la conversion nombre->chaine puis tri des chaines puis conversion chaine->nombre : 5 et 50 commencent par le même caractère...
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia6 + Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 21/12/2018 à 00h13

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 522
Bon, y'a plus de loup...

La formule magique est :
Code VB :
motRef$=right$(SPACE$(longnombre)+liste$(ref),longnombre)


et elle permet de donner à toutes les chaines représentant les nombres, la même quantité de caractères.

D'autres explications moins ésotériques demain, l'est trop tard ce soir.

Il reste un petit bug, lorsqu'on clique une nouvelle fois sur "Sans doublons", mais c'est probablement une variable mal réinitialisée, et ça n'enlève rien au fait que ça marche au premier tour, ce qu'on attend dans cette démo de tri.

Il y a sûrement moyen de simplifier...

Code VB :
 
    nomainwin
    WindowWidth = 675 '455
    WindowHeight = 500
    UpperLeftX = 100
    UpperLeftY = 10
    TEXTBOX #t.n,  10, 10, 40, 25
    BUTTON #t.go, " Go !", [go], UL, 150, 10, 40, 25
   TEXTEDITOR #t.tab, 10, 50, 200, 380
   BUTTON #t.tri, " Tri !", [tri], UL, 240, 10, 40, 25
   TEXTEDITOR #t.trib, 230, 50, 200, 380
   BUTTON #t.doub, " Sans doublons", [doub], UL, 510, 10, 80, 25
   TEXTEDITOR #t.dobl, 450, 50, 200, 380
    GRAPHICBOX #t.m 5, 5, 655, 435
    OPEN "Tri disques" FOR window_nf AS #t
    #t, "TRAPCLOSE [closetri]"
    #t.m , "down"
    #t.m , "fill darkblue"
    #t.m , "color yellow; backcolor darkblue"
    #t.m , "PLACE 60, 20": #t.m, "\ <---N"
    n=50
    #t.n, str$(n)
   diam$=" 5 10 15 20 25 30 35 40 45 50"
   wait
   for x=1 to n
   next x
  wait
  [go]
    #t.n, "!contents? var$": n=val(var$)
    dim bubble(n)
    longnombre=0
    for x=1 to n
      num$=word$(diam$,alea)
      a=len(num$)
      alea= int(rnd(1)*10) + 1
      bubble(x)=val(num$)
      if a>longnombre then longnombre=a
 
    next x
 
      '-----------
    for x=1 to n
      #t.tab, bubble(x)
    next x
  wait
  [tri]
FOR i=1 TO n
    FOR j=1 TO (n-1)
        IF bubble(j) > bubble(j+1) THEN
            temp=bubble(j)
            bubble(j)=bubble(j+1)
            bubble(j+1)=temp
        END IF
        #t.trib, str$(bubble(i))
    NEXT j
NEXT i
  #t.trib, "!cls"
    for x=1 to n
      #t.trib, bubble(x)
    next x
wait
 
  [closetri]
    close #t
  end
'-------------------------------doubles-----------------
[doub]
 
    nbmots=n
    dim liste$(nbmots):dim tri$(nbmots)
 
    for a=1 to nbmots-1
        liste$(a)=str$(bubble(a))
    next
 
    for ref=1 to nbmots-1
 
        motRef$=right$(SPACE$(longnombre)+liste$(ref),longnombre)
        for compare=1 to nbmots-1
            if ref<>compare then
                motCompare$=right$(SPACE$(longnombre)+liste$(compare),longnombre)
 
                'si les mots sont différents
                if motRef$<>motCompare$ then
 
                    'on compare lettre à lettre le mot référence et le mot comparé
                    lettre=1
                    difference=0
                    while difference=0
                        'codes ascii des lettres
                        a=asc(mid$(motRef$,lettre,1))
                        b=asc(mid$(motCompare$,lettre,1))
                        '''''on supprime la distinction majuscules-minuscules
                        if a>96 then a=a-32
                        'if b>96 then b=b-32
                        ''' 'pour quitter l'analyse lorsque les lettres seront différentes
                        if a=b then lettre=lettre+1 else difference=1
                    wend
 
                    if a>b then apres=apres+1 else avant=avant+1
 
                end if
            end if
        next
        tri$(apres)=motRef$ 'tri dans l'ordre conventionnel
        'tri$(avant)=motRef$ 'tri dans l'ordre inverse
        avant=0:apres=0
    next
 
    'suppression des cases vides
    'comptage des cases vides pour dimensionner le tableau définitif
    casevide=0
    for a=1 to nbmots-1
        if tri$(a)="" then casevide=casevide+1
    next
    nbcases=nbmots-casevide
    dim definitif$(nbcases+10)
 
    'transfert des cases non vides dans le tableau définitif
    actuel=1
    for a=1 to nbmots-1
        if tri$(a)<>"" then
            definitif$(actuel)=tri$(a)
            actuel=actuel+1
        end if
    next
 
    for a=1 to nbcases: #t.dobl, definitif$(a): next a
 
    redim bubble(nbcases+1)
    for x=1 to nbcases
      bubble(x)=val(definitif$(x))
    next x
    n=nbcases
 
    'affiche la liste triée sans doublons
    #t.dobl, "!cls"
    for x=1 to n-1
 
      #t.dobl, bubble(x)
    next x
 
 wait
 
 
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia6 + Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 21/12/2018 à 12h54

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2095
ça marche...! ^^
____________________
Roro

   
Le 23/12/2018 à 16h02

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 522
Certes, mais il n'est pas dit que ça marche pour les négatifs : le tri se base sur le code ascii des caractères, et le code ascii de "+" est avant celui du "-".

Donc si on a à trier 5, -5, +12, -20, on obtiendra en intermédiaire, 05,-05,+12,-20, et en définitif +12, -20, -5, 5, encore une usine à gaz en perspective pour obtenir -20, -5, 5, 12...

Ceci dit, dans les données de départ, les nombres sont compris entre 1 et 100 ;)
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia6 + Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 24/12/2018 à 09h40

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2095
Citation:
il n'est pas dit que ça marche pour les négatifs

Mais qui aurait l'idée saugrenue de trier des nombres négatifs ? 3:)
____________________
Roro

   
Le 25/12/2018 à 11h53

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 522
;) Il y a aussi les décimaux, que je n'ai pas testé ni cherché à prendre en compte.

Citation:
D'autres explications moins ésotériques demain, l'est trop tard ce soir.

L'astuce a été de compléter les nombres par des espaces à gauche pour qu'ils aient tous la même longueur en caractères, ainsi les unités sont en face des unités, les dizaines en face des dizaines, etc..., et le tri alphabétique peut fonctionner sur les nombres.
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia6 + Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 28/02/2019 à 17h17

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 522
franckbasic:
Y'a t'il un ordre qui permette d'effectuer un tri en just basic.

Maintenant oui, depuis la sortie de la version 2 de Just BASIC :
Code VB :
 
dim zone(100)
 
'génère les nombre entre 1 et 100
for a=0 to 99
    tir=int(rnd(1)*100)
    if tir=0 then tir=1 'pour respecter l'énoncé de départ ;)
    zone(a)=tir
next
 
'affiche les nombre dans l'ordre de leur création
for a=0 to 99:print zone(a):next
 
'choisissez donc le sens du tri
print
input "tri par ordre croissant (c) ou décroissant (d)";choix$
if choix$="c" or choix$="C" then debut=0:fin=99:chx$="-> ordre croissant"
if choix$="d" or choix$="D" then debut=99:fin=0:chx$="-> ordre décroissant"
print
print chx$
 
'trie le tableau
sort zone(), debut, fin
 
'et affiche les données triées
for a=0 to 99:print zone(a):next
 
end
 


Facile, non ? ;)
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia6 + Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   
Le 28/02/2019 à 19h50

Administrateur

Groupe: Administrateur

Inscrit le: 04/03/2012
Messages: 2095
Citation:
Facile, non ?

Trop facile
Le jour où il y aura une instruction qui fera tout le soft, on n'aura plus qu'à aller se coucher.
Voir Python: T'a besoin d'une cafetière, t'inquiète y aura toujours un module Cafetière quelque part
Import Cafetière !!!
37 mots clés et un milliard de modules.
____________________
Roro

   
Le 01/03/2019 à 07h08

Modérateur

Groupe: Modérateur

Inscrit le: 09/02/2015
Messages: 522
En effet, j'ai entendu que du bien de Python, dont l'inévitable question ; "quand est-ce que tu t'y mets ?" ^^

Mais non, je reste Basic, c'est sentimental et c'est pour meubler sans prétentions quelques heures perdues qui ont la bonne idée de passer à proximité...
____________________
Just BASIC v2.0 :
  • utilisation courante avec GNU/Linux Mageia6 + Wine (Pas trouvé d'incohérences ou de bug de compilation à ce jour)
  • utilisation occasionnelle ou vérification/débugage difficile avec Windows XP sur un petit eeepc

   

 |  |

1 Utilisateur en ligne : 0 Administrateur, 0 Modérateur, 0 Membre et 1 Visiteur
Utilisateur en ligne : Aucun membre connecté
Répondre
Vous n'êtes pas autorisé à écrire dans cette catégorie