From 5903d26b481621f10b19f8962864c409cc0acde5 Mon Sep 17 00:00:00 2001 From: Felix-Vimalaratnam Date: Fri, 8 Nov 2024 16:13:13 +0100 Subject: [PATCH] fin piles --- DEV3.2/Listes/LuminanceApp$1.class | Bin 0 -> 620 bytes DEV3.2/Listes/LuminanceApp.class | Bin 0 -> 3678 bytes DEV3.2/Listes/LuminanceApp.java | 96 +++++++++++++++++++++ DEV3.2/Listes/MaListeChainee$1.class | Bin 0 -> 1043 bytes DEV3.2/Listes/MaListeChainee$Node.class | Bin 0 -> 537 bytes DEV3.2/Listes/MaListeChainee.class | Bin 0 -> 1997 bytes DEV3.2/Listes/MaListeChainee.java | 94 ++++++++++++++++++++ DEV3.2/Listes/MaListeTableau$1.class | Bin 0 -> 938 bytes DEV3.2/Listes/MaListeTableau.class | Bin 0 -> 1977 bytes DEV3.2/Listes/MaListeTableau.java | 78 +++++++++++++++++ DEV3.2/Piles/Arithmetique.class | Bin 0 -> 2289 bytes DEV3.2/Piles/Arithmetique.java | 58 +++++++++++++ DEV3.2/Piles/chaine/Arithmetique.class | Bin 0 -> 2269 bytes DEV3.2/Piles/chaine/Arithmetique.java | 56 ++++++++++++ DEV3.2/Piles/chaine/Pile.class | Bin 0 -> 306 bytes DEV3.2/Piles/chaine/Pile.java | 7 ++ DEV3.2/Piles/chaine/PileChainee$Node.class | Bin 0 -> 522 bytes DEV3.2/Piles/chaine/PileChainee.class | Bin 0 -> 1089 bytes DEV3.2/Piles/chaine/PileChainee.java | 43 +++++++++ DEV3.2/Piles/tableau/Arithmetique.class | Bin 0 -> 2269 bytes DEV3.2/Piles/tableau/Arithmetique.java | 56 ++++++++++++ DEV3.2/Piles/tableau/Pile.class | Bin 0 -> 306 bytes DEV3.2/Piles/tableau/Pile.java | 7 ++ DEV3.2/Piles/tableau/PileTableau.class | Bin 0 -> 1198 bytes DEV3.2/Piles/tableau/PileTableau.java | 47 ++++++++++ 25 files changed, 542 insertions(+) create mode 100644 DEV3.2/Listes/LuminanceApp$1.class create mode 100644 DEV3.2/Listes/LuminanceApp.class create mode 100644 DEV3.2/Listes/LuminanceApp.java create mode 100644 DEV3.2/Listes/MaListeChainee$1.class create mode 100644 DEV3.2/Listes/MaListeChainee$Node.class create mode 100644 DEV3.2/Listes/MaListeChainee.class create mode 100644 DEV3.2/Listes/MaListeChainee.java create mode 100644 DEV3.2/Listes/MaListeTableau$1.class create mode 100644 DEV3.2/Listes/MaListeTableau.class create mode 100644 DEV3.2/Listes/MaListeTableau.java create mode 100644 DEV3.2/Piles/Arithmetique.class create mode 100644 DEV3.2/Piles/Arithmetique.java create mode 100644 DEV3.2/Piles/chaine/Arithmetique.class create mode 100644 DEV3.2/Piles/chaine/Arithmetique.java create mode 100644 DEV3.2/Piles/chaine/Pile.class create mode 100644 DEV3.2/Piles/chaine/Pile.java create mode 100644 DEV3.2/Piles/chaine/PileChainee$Node.class create mode 100644 DEV3.2/Piles/chaine/PileChainee.class create mode 100644 DEV3.2/Piles/chaine/PileChainee.java create mode 100644 DEV3.2/Piles/tableau/Arithmetique.class create mode 100644 DEV3.2/Piles/tableau/Arithmetique.java create mode 100644 DEV3.2/Piles/tableau/Pile.class create mode 100644 DEV3.2/Piles/tableau/Pile.java create mode 100644 DEV3.2/Piles/tableau/PileTableau.class create mode 100644 DEV3.2/Piles/tableau/PileTableau.java diff --git a/DEV3.2/Listes/LuminanceApp$1.class b/DEV3.2/Listes/LuminanceApp$1.class new file mode 100644 index 0000000000000000000000000000000000000000..4ae02de4f025d85eee96f9613bdf21ed82ae67ea GIT binary patch literal 620 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 FBmk2 colors = new ArrayList<>(); // Liste des couleurs des parallélogrammes + private final int parallelogramWidth = 100; + private final int parallelogramHeight = 50; + + public LuminanceApp() { + setTitle("Luminance App"); + setSize(600, 400); + setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + setLocationRelativeTo(null); + + // Générer 10 couleurs aléatoires et les ajouter à la liste + generateRandomColors(10); + + // Ajouter un MouseListener pour détecter les clics + addMouseListener(new MouseAdapter() { + @Override + public void mouseClicked(MouseEvent e) { + handleMouseClick(e.getX(), e.getY()); + } + }); + } + + // Génération des couleurs aléatoires + private void generateRandomColors(int numberOfColors) { + Random random = new Random(); + for (int i = 0; i < numberOfColors; i++) { + Color color = new Color(random.nextInt(256), random.nextInt(256), random.nextInt(256)); + colors.add(color); + } + } + + // Gestion du clic de souris + private void handleMouseClick(int x, int y) { + int index = getClickedParallelogramIndex(x, y); + if (index >= 0 && index < colors.size()) { + Color color = colors.remove(index); // Supprimer la couleur cliquée + float luminance = calculateLuminance(color); + System.out.println("Luminance de la couleur supprimée : " + luminance); + repaint(); // Redessiner la fenêtre avec les parallélogrammes restants + } + } + + // Calcul de la luminance selon la formule donnée + private float calculateLuminance(Color color) { + return 21 * color.getRed() + 72 * color.getGreen() + 7 * color.getBlue(); + } + + // Récupère l'index du parallélogramme cliqué + private int getClickedParallelogramIndex(int x, int y) { + int posX = 50; + int posY = 50; + for (int i = 0; i < colors.size(); i++) { + if (x >= posX && x <= posX + parallelogramWidth && y >= posY && y <= posY + parallelogramHeight) { + return i; + } + posY += parallelogramHeight + 10; // Espace entre les parallélogrammes + } + return -1; + } + + // Dessin des parallélogrammes dans la fenêtre + @Override + public void paint(Graphics g) { + super.paint(g); + int posX = 50; + int posY = 50; + for (Color color : colors) { + g.setColor(color); + drawParallelogram(g, posX, posY, parallelogramWidth, parallelogramHeight); + posY += parallelogramHeight + 10; // Espacement vertical + } + } + + // Dessin d'un parallélogramme + private void drawParallelogram(Graphics g, int x, int y, int width, int height) { + int[] xPoints = {x, x + width - 20, x + width, x + 20}; + int[] yPoints = {y, y, y + height, y + height}; + g.fillPolygon(xPoints, yPoints, 4); + } + + public static void main(String[] args) { + SwingUtilities.invokeLater(() -> { + LuminanceApp app = new LuminanceApp(); + app.setVisible(true); + }); + } +} diff --git a/DEV3.2/Listes/MaListeChainee$1.class b/DEV3.2/Listes/MaListeChainee$1.class new file mode 100644 index 0000000000000000000000000000000000000000..a414cf6e1708412efa740db6647e6287f494c881 GIT binary patch literal 1043 zcmX^0Z`VEs1_mbvYfc6x24;2!79Ivx1~x_p0pCQQ%;J(%=ZwV6ywp?`Lq-O+l8nq^ z6$3^F0UuOJYc2*322OScE*=JM1|CKRfvm)`ME#t^ymWp4q^#8B5=I6#o6Nk-5<5l) zW)00SP6j>(es%@{9tJ@MAw~v1RMQw4STa%*Qy3XU(X3JN%TGxKyHkXRK@_BuJ-M`~ zC^fHyi-CzjoQFYzL6VVyJtMK$FSVisY*iFHgES+90@yvJC7C(;e)++r$r-LWsky0n zC9W08sRbpO`FUInQVg7&3~~(e>NOMg|t={FGEi27aH+yi~u^+@#c^ki?{%R8X9ymSp6o1SA$E=BAdU z78Nrx@CKJ8CTII57C@DVXlPwHnvp>pQxYPA;scoTxPtRbi;`2_GC`K3 zg_j=4AqmM@i3S%m@_hPWWobO4CW#fE36qAIQ&wJOFZ(6OBfk= zJoEBWi=1;3i;Gi>85vkW34uX@fr){GfssLtfr)_$lpYuu88jFe7?>C|1q48en1O+T znSp_Un?Z|#i9wrzfx#54l7T@~OM5E=qtgr7;FZuxSPij0}tn3=F(lTNs3oF|e~NXJBDo z19kw&6gIGA0D~S#Hv<#514y+hgFe(Pp-{J|Xl-Kl2T pnvEGu7#J8>82A`W87#med<>Qh3=Be0XD~1@Fvv0RF<3Eh0RT&-+H?Q_ literal 0 HcmV?d00001 diff --git a/DEV3.2/Listes/MaListeChainee$Node.class b/DEV3.2/Listes/MaListeChainee$Node.class new file mode 100644 index 0000000000000000000000000000000000000000..dd91e9c2bcc605e7214c0502ad8d5103712eda27 GIT binary patch literal 537 zcmX^0Z`VEs1_mbvIW7h!24;2!79Ivx1~x_pfvm)`ME#t^ymWp4q^#8B5=I6#o6Nk- z5<5l)W)00SP6iGJPId+^9tLg(9!3UX-$b9x;*wP7jKs{m)KnF}{FGEi29}h>l0-%Z zAs=+ZtQi?NgEQ0f5=%;pQW+VTLtL#H8CddCD@qs{M18QBWzEPSg-zTh#MRo)nvp?N z1Je%8Fh&LzXRt%~eKPY>{YrC_Qj0L$t_!yWO7#MgNSQz*iI2rh%CW8vO8b0X8SZjuH zGVn6+u`}@VFbFURGBWU?8p6oHl98I2!pI=%gDL?w-I|kuok5s~K?J0eB`>w21Z0{R z4}&;^1S11Wab{I2BLkx+JA)J>gEGQy&%Bh>3jfj)|1_uk(!7*n*NWuSf|AVqJRt@K z1{od(Sq3>q2Jzg)>{RFcyyV1^@XV47=ls0llEl1{Vnzlr4Np%^B(DUQ6lLb6TXQi; zGAMw&s)*)Qs65E4>*FShFlD444NR* zwHO(MHP8aX8WaOMj0{3Zek@5XN=(X0Wn|zC&P>lsEGaEYWn_>-(+Cbln-EuPJ8MP; z7U%qwR7M7VpUk{eztY^K)S?iG3CxKpDU1xf!6k{w*}jPdP*FCG5Lau>FmQNa`T``u zuHgw)!knI30tywBaD)1nk%3LaQ!~WX8l03o85uY-L2fU}F9I124d~L6%p84BsJJyF zgR}-V37AhDZCtG|on(h8gd_qsJSis?W(HSqerZv1s#_)~4AGLd9w?j{8MysYi%Wb{ zK_OMl$ROa9pI=g3Qj}QWn_7~QpHj@h;LOM%2u^HP3XD1m!I@R5Rtk*#Yz(ek3~mhW z>Q^&x2nlKk8flS}f8Dj6AOAZH+`LWo@+iFqkGsl_Tj z`T5zU1=dL3f*6D>f}$~`vLF>%5~@5J$pmOLLBktd20)E)PRz*(&MZl_W@O;;%*#tH za?VLCE>10GWMBd1eRc+4Mg~<3uVHgBJA*$XgB*UPj0|iL?=dJc@G>wlFfwQ}FflNJ ziVX%v23-aQ1||kQ1}0G6XJBApV_*aoT?~v2`V0&VvJ8w2j0_A6tXkU{7&kI7FfcM0 zKov1CurM$(7&34(FoBi!FfcQ)FfcIK>}Ft()ZWg(>8rJcf#)~_x0cRU2A<^%G9a#> z?iL22V+`CN%5VAqFSEKqM5gI#C> zb>STb76vv328Lqk*$mv$T3Z-ImoSL#W{`{ovv)B_Gcastklzn-zs`0BPCw~c48pov zTNrpiZqx;P!T`jzVqrF86=juXNm;}oAjz_YLCA`wg_Uvn|984z-c|-7Nfup@CM+Ja zV&G$7U{GcN6=!k`>I~`(8VuSDnheGaS`5|DEZU}O+yu*67GTNp&wpd~3+21W)e z25YGE6&aYpsgH9vgIc84b_NZQYmif*H`E3j239D`mcb6}VtWP$a5`mTU}sQcaAaU$ p;9y{6aA9C%aANRcU|^79U}j)v;AQY;096nSVBo{x#}L3E2>?f}ycqxh literal 0 HcmV?d00001 diff --git a/DEV3.2/Listes/MaListeChainee.java b/DEV3.2/Listes/MaListeChainee.java new file mode 100644 index 0000000..0bc28a6 --- /dev/null +++ b/DEV3.2/Listes/MaListeChainee.java @@ -0,0 +1,94 @@ +import java.util.Iterator; +import java.util.NoSuchElementException; + +public class MaListeChainee implements Iterable { + private Node head; // Premier élément de la liste + private int size; // Taille de la liste + + // Classe interne représentant un nœud + private static class Node { + E data; + Node next; + + Node(E data) { + this.data = data; + } + } + + // Ajoute un élément à la fin de la liste + public void add(E element) { + Node newNode = new Node<>(element); + if (head == null) { + head = newNode; + } else { + Node current = head; + while (current.next != null) { + current = current.next; + } + current.next = newNode; + } + size++; + } + + // Ajoute un élément à une position spécifique + public void add(int index, E element) { + if (index < 0 || index > size) { + throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size); + } + + Node newNode = new Node<>(element); + if (index == 0) { + newNode.next = head; + head = newNode; + } else { + Node current = head; + for (int i = 0; i < index - 1; i++) { + current = current.next; + } + newNode.next = current.next; + current.next = newNode; + } + size++; + } + + // Retourne l'élément à une position spécifique + public E get(int index) { + if (index < 0 || index >= size) { + throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size); + } + + Node current = head; + for (int i = 0; i < index; i++) { + current = current.next; + } + return current.data; + } + + // Retourne la taille de la liste + public int size() { + return size; + } + + // Méthode pour l'itération + @Override + public Iterator iterator() { + return new Iterator() { + private Node current = head; + + @Override + public boolean hasNext() { + return current != null; + } + + @Override + public E next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + E data = current.data; + current = current.next; + return data; + } + }; + } +} diff --git a/DEV3.2/Listes/MaListeTableau$1.class b/DEV3.2/Listes/MaListeTableau$1.class new file mode 100644 index 0000000000000000000000000000000000000000..e060ee2ea7f33578c283e726cd72928d3f1fb408 GIT binary patch literal 938 zcmX^0Z`VEs1_mbvQ%(jZ24;2!79Ivx1~x_p0pCQQ%;J*Nki?{%)WlL1Lq-O+l8nq^ z6$3^F0UuOJYc2*322OScE*=JM1|CKRfvm)`ME#t^ymWp4q^#8B5=I6#o6Nk-5<5l) zW)00SkX3v<4EziNj0`-9%)7$g`Z85!6!5{vy(D@wp-N3kL4lEhBNd{en2|v^+6Sy1$^F*s3`&d)LSSLAsh%aN zMTsT(MT`u>8t8$c8OF%K;+&t7%E-X)lbM(5SDKrYS_BS9P_U+!WaOs=Bo-y+rk11@ z6*DsM2A3ozXZt1=K$WoMfjuLlp^51ZMh4E{%=Em(lG377Mg~?5%@9{>Mh0z6g%A-G zx7vibTH9GOGH?awmlh?bx@G31GBOCG2Cp8-i;N8Xu6fBh`Nf%e>Aqm+@-P@O7%?(% zWWv2I26G*X71oRl9Db?AB_8?3C5#L_o_TqxMb0^i#l@+`3*xM42ld)3{0T7 zXJ8Nz0Hrks1_ovZ1_o{hWd+Zoukn71gr3nT`usP-oObm<+3=AS#TNrq?wlFYm zVGvxzz|OLqfrWVu0|NsS*f2J*8Yc#IkRc3ALJo`!j0_qKno!61FtCCZC~IwF5Szuo zy_-QQayx^}eu#OpT9I2Ac%xVnwleSVeg-YD5^V-n nC`*Sy7c8R3pwGa-z``KJV8CDu77=1FVPIh3Vqj!oVgLgGmh8ea literal 0 HcmV?d00001 diff --git a/DEV3.2/Listes/MaListeTableau.class b/DEV3.2/Listes/MaListeTableau.class new file mode 100644 index 0000000000000000000000000000000000000000..58157c1c6aa079b15c5fedd6f379a48aaa84c750 GIT binary patch literal 1977 zcmX^0Z`VEs1_mdFKrRL*24;2!79Ivx1~x_pfvm)`ME#t^ymWp4q^#8B5=I6#o6Nk- z5<5l)W)00SP6iGJPId+^9tLg(9!3T}-$b9x;*!*m#H5_m#8O5Emg3B+R7M6yPmn@B z9tM5}0Y(On)ST4Z)Vz{nMh4+%A9Ne6xfnPYgm@T)LH6^d<`tI~r8*}TBqnE;RI)RO zGBPM5ba>{aq*nNsmiVVR<(KBA6uVX=rxuiC=I049FffSoFi0>+GBSwgCT6EP=jSCS zmV{@PWH{&N6_+G}Z5Pw<^wdOhKyXP>W?s5A7lR0cG$;UM7#T!0Fy%GFxESOZBu`)Toppub63)u`vFj{*e84DBg)C^;1P+?>cKn+C| zLoNno1~rg_)EOCsHGEK|twFjp85x9-f~6$22owX144lE4>3NAIrA4WX3@p(huGWkU z0-k=JA)byt@y?C`j?SJTk&FzyurLWr%qdM}W?*38Vq{=(&QD2YWZ?J7%uDqv%}q)z z0>>&N19M_Z3R=KGeV`e}$iSu%;%W_Ih-qN)BS?ZbxFj(-+c&WQY970WCsYe_dTI&C zWRysOnhi49Qxoh1W(`eGMh1>dkS|N}ix?TiG@!9qT9TQg?+F#RW@M1YDq$1iYHerD z$lz$>YK0jMc9=p)B4ERla#CSta0Ta=7A2>;W#*(ZG6(vTnz3E9_$RB zpoHwj$e;o;50V)(^UCtGQ}rPU7LvBz5|c~viz*ozW*{dws6vQc9*KD=IjO}eKKc3C zr3KbV-hvo}EP|pjq_Q9tSrV!oOXh_}1h~Y28sVInlM|d-l4{M!z~h;hms;eUlUQ7w zTFlPi%gCUL;U{cPWoPhbWRSzJl#ziA;x7h81`Y-$21W)A24)5(P?5vH$e_i*z`(?y z&AO_)KHK?LelW3X8!P_t$;u!3z1 zlAg`LEv>bMfqe;s=xzp)NHBXBgBSzDb_S{aP@CB8WTlrdh=c5u1rsbOM!_x2|Cj%N z1>#EU1cRLdb_vKGOkn@0F>o?4Fi0@)Fi0}UF-S8gF~~CLFvu}jF~~AFFeos%Gbl0y zGAJ>aGB7Z3GqCUo{$b!?{KX&vb+8!&BZE1E1=PX*3@l*JtHK?;5UYc?Fz`wnZ2(6C zC`=(?p~k?&pw1x2pb55%g@K7j5Ne4f10w@BgB3KIWEmJ47#SECSU~}@1|BhNU_m_w zCQuy$RT>M83>}bCP$2AEz@P-CSu^%BF!_L(%-YN#YTph9SuJg7R6~MBjDeMbfx(!8 zhrxtFoWYbqjlqmTo52F?JZ1()Z3adLYX%#r*A*FKR)GRw&Dk!5$n04h)VA3=Av`j10;QP7DkT91M&Mt_+L}&J5n*1jodn%m4vC41Np& G43Yq`b+y_6 literal 0 HcmV?d00001 diff --git a/DEV3.2/Listes/MaListeTableau.java b/DEV3.2/Listes/MaListeTableau.java new file mode 100644 index 0000000..46d1d49 --- /dev/null +++ b/DEV3.2/Listes/MaListeTableau.java @@ -0,0 +1,78 @@ +import java.util.Iterator; +import java.util.NoSuchElementException; + +public class MaListeTableau implements Iterable { + private E[] elements; // Tableau pour stocker les éléments + private int size = 0; // Nombre d'éléments dans la liste + + // Taille initiale du tableau + private static final int INITIAL_CAPACITY = 10; + + // Constructeur + public MaListeTableau() { + elements = (E[]) new Object[INITIAL_CAPACITY]; + } + + // Ajoute un élément à la fin de la liste + public void add(E element) { + ensureCapacity(); + elements[size++] = element; + } + + // Ajoute un élément à une position spécifique + public void add(int index, E element) { + if (index < 0 || index > size) { + throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size); + } + ensureCapacity(); + // Décaler les éléments vers la droite pour insérer à l'index + for (int i = size; i > index; i--) { + elements[i] = elements[i - 1]; + } + elements[index] = element; + size++; + } + + // Retourne l'élément à une position spécifique + public E get(int index) { + if (index < 0 || index >= size) { + throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size); + } + return elements[index]; + } + + // Retourne la taille de la liste + public int size() { + return size; + } + + // Assure la capacité du tableau pour accueillir plus d'éléments + private void ensureCapacity() { + if (size == elements.length) { + E[] newElements = (E[]) new Object[elements.length * 2]; + System.arraycopy(elements, 0, newElements, 0, elements.length); + elements = newElements; + } + } + + // Méthode pour l'itération + @Override + public Iterator iterator() { + return new Iterator() { + private int currentIndex = 0; + + @Override + public boolean hasNext() { + return currentIndex < size; + } + + @Override + public E next() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + return elements[currentIndex++]; + } + }; + } +} diff --git a/DEV3.2/Piles/Arithmetique.class b/DEV3.2/Piles/Arithmetique.class new file mode 100644 index 0000000000000000000000000000000000000000..37b6decda99ed4cb6d8069a727355609f9edb745 GIT binary patch literal 2289 zcmX^0Z`VEs1_mdFGA;%t24;2!79Ivx1~x_pfvm)`ME#t^ymWp4q^#8B5=I6#o6Nk- z5<5l)W)00SP6iGJPId+^9tLg(9u(!lmBl5gxr_|V`K2X{45B_@gEI5=1Bx>9N`gy@ zQWJBnIT-jD863h=OEYtFQmYiw@=J^IGK&;S^HLR3D+-EIi;FY!^Au9^6!P**5=%hr zg8ZEPyu{4nRE5mEvecsD!z)wuxEKT&1lbvcco>8kL>L)_vDn1Oz+M2dHz$vgK~w|c z7Okn z2ZJgj1EVengE}JvV+99;CL;r*J~x9lgAO}`E)RnqgFYhzKf-}vw=ps>7vvW(GKgqs zB6$jGBs+s4BZDAV2iUKkc_pdosYP521`NhL3??9daAf9{geB&HJZZpS#=~IFV8O`1 zUIr5JPh(^d)9^$#7ixet$Wc~24Au-bj0`LVrNtRIycEXHV8_THi*SKsQD#X-ZfZ$p zvTH?hY5^!lIT#!m8H8Li%QC@nU65F$P<41^Q9c)gErSy%5sHA^>%zm}%HYPxz)_G` zRGjLW2TD=cqR|uNG!GsIPmt$WiZiQHK@s2$@|X`JgBr3HXdof`51JT+7#JA*co_T{ z0vH*@a}%>uo%8dO6HCG~OER4E^NLFn^Gb@*41?;#Vi*TQ5F>-UYf({ZX_11Jf-53f zXXYj67Zs%@m!#^kGlam>EjXs&p~J-x%n-)I5Y7<6$iS7JTH>2pT%4GmiXP!m>xCE? z8T{B8q8S-@;2~XDn##z)0!f$rKACx`ex5L4_whD|K44I4!2G9`7$uBBaNJ&-5Q9ryAlnf!c9xQ-VB3LOf^0P5y zb1~#F!PSuC_1QLC2iOD7TMU{*UGmujOR3XGo9*KD= zIjO}eKKc3Cr3KcQL4qWLqA{ehAQg*pD9fQf+-RLnClGQ==2 zFvv16GB7eQFtBQEXJFjOz`(%B5X->8zy=m%Vc=wlV~B?+Wtzmm%)rIKz<5Aw-z)~6 zO$_WpyxSP~H|}N-joi*4?xW?av(Jv%j75}1b`fKejwp+f6{{qx6&sToyCmB-28q=m z%hMSc7+4q>7_=D}7_=A|7<3sJ7_1l=81xw!7@`;$7%CVT7`!Cegygm{D9mIqV>V-7 z&R`(PCZq!9tFeIi3X*I>YGA$?D~K;3$tI)$=CiSxv5T^=Vqjpn0J4mMfq@z9MNlQj zz>v?tz%WHydnbbyBf|j(gKZ2($n1n245m97ESVUVGt5U8H{(FzacYZligKhN6c^z% zF$1B<7sU)T6Gb^@G4SqYu#FV5-_GE;A8bJmLa(53*+*C^R#y|xHB@a zEMSn@#J~#+24%(&1{KCQ1~tYU26e`K1}(-~27bn71_Q=k z21CXr491LW7%UjqGng@MU@&Lg&tS=rz`(#@!ywG}pMjr&m7O7xok5$OA(4@hf#Dy6 zBRhj6JA))6KR-W@oQjUhUj{8k#-9uVKNxs_Ft94HJFzna^D{6rBr`BDFfpVsq%trt g@G&qkWHB%@q=Cr{h5`l#1}+9hhC+s7hEfJe04KdRkN^Mx literal 0 HcmV?d00001 diff --git a/DEV3.2/Piles/Arithmetique.java b/DEV3.2/Piles/Arithmetique.java new file mode 100644 index 0000000..b6523d8 --- /dev/null +++ b/DEV3.2/Piles/Arithmetique.java @@ -0,0 +1,58 @@ +import java.util.ArrayDeque; +import java.util.Deque; + +public class Arithmetique { + + public static void main(String[] args) { + if (args.length == 0) { + System.out.println("Veuillez fournir une expression en notation polonaise inversée."); + return; + } + + Deque stack = new ArrayDeque<>(); + + try { + for (String token : args) { + switch (token) { + case "+": + // Addition + stack.push(stack.pop() + stack.pop()); + break; + case "-": + // Soustraction (attention à l'ordre) + int b = stack.pop(); + int a = stack.pop(); + stack.push(a - b); + break; + case "x": + // Multiplication + stack.push(stack.pop() * stack.pop()); + break; + case "/": + // Division (attention à l'ordre) + b = stack.pop(); + a = stack.pop(); + if (b == 0) { + throw new ArithmeticException("Division par zéro"); + } + stack.push(a / b); + break; + default: + // Si ce n'est pas un opérateur, alors c'est un nombre + stack.push(Integer.parseInt(token)); + break; + } + } + + // Le résultat final doit être le seul élément restant sur la pile + if (stack.size() == 1) { + System.out.println("= " + stack.pop()); + } else { + System.out.println("Erreur : Expression incorrecte."); + } + + } catch (Exception e) { + System.out.println("Erreur lors de l'évaluation de l'expression : " + e.getMessage()); + } + } +} diff --git a/DEV3.2/Piles/chaine/Arithmetique.class b/DEV3.2/Piles/chaine/Arithmetique.class new file mode 100644 index 0000000000000000000000000000000000000000..d8e59fa4c657db5c969462b8859ea53f1b468387 GIT binary patch literal 2269 zcmX^0Z`VEs1_mdFGA;%t24;2!79Ivx1~x_pfvm)`ME#t^ymWp4q^#8B5=I6#o6Nk- z5<5l)W)00SP6iGJPId+^9tLg(9u(!lmBl5gxr_|V`K2X{45B_@gEI5=1Bx>9N`gy@ zQWJBnIT-jD863h=OEYtFQmYiw@=J^IGK&;S^HLR3D+-EIi;FY!^Au9^6!P**5=%hr zg8ZEPyu{4nRE5mEvecsD!z)wuxEKT&1lbvcco>8kL>L)_vDn1Oz+M2dHz$vgK~w|c z7O3Ub^0^pn8Js`~P6XsM7aj&z1~*0qj)KIZ;#AK(Q0l=J zWu73XdGIiJf;`7koLQ9$3UzOg$9xzW)R4760}0uG(1;geU|{g$Ven@NU}O-_P0UVp z&d*CuED6sn$#BlkD=taQD=9`Z45|~0VH^xWj12OwMMbHlMG965u81U@nU|bjRFs-r zlB&nf5CTi1;FyAk4i`f(Ll_T3I70*@16O)#iEnCgabkKZdW1u*7h+&!@MC9)W@O-j zhjd|SDkB36Br)>)Wag#%mF6a;7KJ1x<$xq|6EpKb@f?kme4wUjhA}em2A3ozXZt1= zfYq}zBr!4wV^PY;z!jWdT9lmXmI*Rd5ZQJ;Q1ml02sq{EmlT&2B^LOmmSp6o6mu}7 zGcqvSDll>|WHK@sKtm`ezo=LtB~>9u{qRaqGKA!CumDo-w^Cr_XJg3bV#s00WoO6( z#Z^8dg9^wdNV$}mSC*fhst@rAB>LPElS}f8Dj6AOAg2PTLWr9@67y1WQj1l5^7FGx z3#>7N1W5!%V@PE|Di-C)A>|J)DXo!H2-FDY#GIVq%#u`VMg|_wyu8#R=bXgi;?!bx zh9X7=RSZ92b1FMS2_u6Xex-~IY!H7jC^AGbFfo7t69XftNM~SVh+$x0kY!+GU}Rum zVAa~rz_^itfq{`BmVtqR4J^pWz{wED5D!txG>L(kfs28G@qpI8Sqwaz7}$k)w=wW< z+|3{wxt&4WN6S}dpB=LqiztiiBE}>gQ5GXBR!LSXHYPK6Nw#ea601R$r!z1xurM$% zXfrS{XfZG_=rS-cSTQg#=rb@dL@_WhR4_0wcuBGe$!%j$n8{$qY{tHv!9bEtNCnJS zV*&9MB-w=2zV^CqtVNhkvXV74*W#DCOX3%5oWzc6_!eGd_hQW++ zJ%b731_o2c{S4*|2@DJjHVndi{~7ohSlJm8*%`Fi84?*885sUCII=THvNK3B^7Hfa z$f@Y4{AJK$Wc@PmQ(2Lr1DyAwM@Fh2t`Lox#c0~13ELn;FU10MquLly%gLmHUO VU?^Z stack = new PileChainee<>(); + + try { + for (String token : args) { + switch (token) { + case "+": + // Addition + stack.push(stack.pop() + stack.pop()); + break; + case "-": + // Soustraction (attention à l'ordre) + int b = stack.pop(); + int a = stack.pop(); + stack.push(a - b); + break; + case "x": + // Multiplication + stack.push(stack.pop() * stack.pop()); + break; + case "/": + // Division (attention à l'ordre) + b = stack.pop(); + a = stack.pop(); + if (b == 0) { + throw new ArithmeticException("Division par zéro"); + } + stack.push(a / b); + break; + default: + // Si ce n'est pas un opérateur, alors c'est un nombre + stack.push(Integer.parseInt(token)); + break; + } + } + + // Le résultat final doit être le seul élément restant sur la pile + if (stack.size() == 1) { + System.out.println("= " + stack.pop()); + } else { + System.out.println("Erreur : Expression incorrecte."); + } + + } catch (Exception e) { + System.out.println("Erreur lors de l'évaluation de l'expression : " + e.getMessage()); + } + } +} diff --git a/DEV3.2/Piles/chaine/Pile.class b/DEV3.2/Piles/chaine/Pile.class new file mode 100644 index 0000000000000000000000000000000000000000..95c37e29a26b7984a8a076eecf44a1432e11ab5a GIT binary patch literal 306 zcmX^0Z`VEs1_mbvVRi;4Mh2FE%$!tq1{OvJfvm)`ME#t^ymWp4q^#8B5=I7=g3{s) zMg~z0A9Oiu%`ip=&fv`Syu^~yqEto(HjNNhupo0megPwch=wMn9!3UM4b2c&Yeoi^ z;>@a4Mh0dLO;1J!_RM0}+=7xyFh7csLBqz?3RANkrVt|oS8#r5QF5wVW=<+211HEU zdLWmwF)}bRFf)Jv3kxFyD+3z?BLh1F0|OHS2MZ$uCj%Fp&&|Tfz{9}H015#<27a&_ Mh)MwlK`>7U04GpCM*si- literal 0 HcmV?d00001 diff --git a/DEV3.2/Piles/chaine/Pile.java b/DEV3.2/Piles/chaine/Pile.java new file mode 100644 index 0000000..7e11a14 --- /dev/null +++ b/DEV3.2/Piles/chaine/Pile.java @@ -0,0 +1,7 @@ +// Interface représentant une pile +public interface Pile { + void push(E element); // Ajoute un élément en haut de la pile + E pop(); // Retire et retourne l'élément en haut de la pile + int size(); // Retourne la taille de la pile + boolean isEmpty(); // Vérifie si la pile est vide +} diff --git a/DEV3.2/Piles/chaine/PileChainee$Node.class b/DEV3.2/Piles/chaine/PileChainee$Node.class new file mode 100644 index 0000000000000000000000000000000000000000..1691a25a2cb9a757eff64e9fac5f573b67e340d2 GIT binary patch literal 522 zcmX^0Z`VEs1_mbvIW7h!24;2!79Ivx1~x_pfvm)`ME#t^ymWp4q^#8B5=I6#o6Nk- z5<5l)W)00SP6iGJPId+^9tLg(9!3U%fXtj!=ZwV6ywp?`zx+X>0|P&U0Guz#z{tSBz{()Rz{DWTz`&rzzy#LArL~=bQA>L( z1N%k>1_nk35e5bZJ_cq61_pKp7Ert}a6(NKWnh7_#2CcEc1SQtf@vuR83qOhE(S&h L4hAU(Sq3fu^}1_K literal 0 HcmV?d00001 diff --git a/DEV3.2/Piles/chaine/PileChainee.class b/DEV3.2/Piles/chaine/PileChainee.class new file mode 100644 index 0000000000000000000000000000000000000000..169084a09f19ef5eae75b1bda04af84da0045d63 GIT binary patch literal 1089 zcmX^0Z`VEs1_mbvYc2*R24;2!79Ivx1~x_pfvm)`ME#t^ymWp4q^#8B5=I6#o6Nk- z5<5l)W)00SP6iGJPId+^9tLg(9!3W4fXtj!=ZwV6ywp@i2A1N?s#Hb>Mo)GIK1K!s zBsmqo{FGEK23`gMkUfHo45Au7=r&nHOc&;15MdByWMD4IFJNR4@Fh&OE0#FEvXlP;vB_jiG za7kivwr^qqR5PoFW{9gbI9NOx8H{aQtuS@jVG4m=33C}&aDHh~a;jS<$Ti5(s|WHn zBLlZzYH^8gD#*#jj0`-Ud3mWt&N+$2#i_-N3@o4|z@W&$!NA18$e_W%#J~iKXa+_G zEd~Y#CI)Q=CQzDUU|?WnU<4&b21W)Q1_lN-uzCgtF0Jhhj9ScF8Q3>6FfcGO=rS-c zfD$iAFAD=N10#bTgCGMFSdS+IGXpaN1B2pj2Hr^R?F{_BI$B#8gtjt>Y3Xcb5Ymd= z!obdwfMS#w11kdqgCGMZgAjutgD`^_g9w8HgDBK-`V5Q=1`LK!<5L-!8JHLt7!0(w zF-Xp2;N8t28!05eok4Lw$d)Y(Dn42eh8Wzkl&uWx+8e+g1vy-bfsKKIL6U);L5e|; zL54w+L6$*L7u^gfq{XUfl&}@wJ`%D12=;SG&E!x7#SErVWhQ%fqe};AlSfy zDh!OETmV&S09DEhQaX!)on<)#3o}Ry6FBT3S~S7du`)1mJ1{b^K&>=oFax{PoWX*D Wfq{jAk%5=N5**wh76*eB0~Y`tcE<$( literal 0 HcmV?d00001 diff --git a/DEV3.2/Piles/chaine/PileChainee.java b/DEV3.2/Piles/chaine/PileChainee.java new file mode 100644 index 0000000..6c97f28 --- /dev/null +++ b/DEV3.2/Piles/chaine/PileChainee.java @@ -0,0 +1,43 @@ +// Classe PileChainee utilisant une liste chaînée pour stocker les éléments +public class PileChainee implements Pile { + private static class Node { + E data; + Node next; + + Node(E data) { + this.data = data; + } + } + + private Node top; // Le sommet de la pile + private int size = 0; // Taille de la pile + + @Override + public void push(E element) { + Node newNode = new Node<>(element); + newNode.next = top; // Le nouvel élément pointe vers l'ancien sommet + top = newNode; // Le nouvel élément devient le sommet de la pile + size++; + } + + @Override + public E pop() { + if (isEmpty()) { + throw new IllegalStateException("La pile est vide"); + } + E data = top.data; // Récupère la donnée du sommet + top = top.next; // Le sommet devient l'élément suivant + size--; + return data; + } + + @Override + public int size() { + return size; + } + + @Override + public boolean isEmpty() { + return size == 0; + } +} diff --git a/DEV3.2/Piles/tableau/Arithmetique.class b/DEV3.2/Piles/tableau/Arithmetique.class new file mode 100644 index 0000000000000000000000000000000000000000..da9a8f296fffb6a6ce58f1fffd8b63951d66a326 GIT binary patch literal 2269 zcmX^0Z`VEs1_mdFGA;%t24;2!79Ivx1~x_pfvm)`ME#t^ymWp4q^#8B5=I6#o6Nk- z5<5l)W)00SP6iGJPId+^9tLg(9u(!lmBl5gxr_|V`K2X{45B_@gEI5=1Bx>9N`gy@ zQWJBnIT-jD863h=OEYtFQmYiw@=J^IGK&;S^HLR3D+-EIi;FY!^Au9^6!P**5=%hr zg8ZEPyu{4nRE5mEvecsD!z)wuxEKT&1lbvcco>8kL>L)_vDn1Oz+M2dHz$vgK~w|c z7O3Ub^0^pn8Js`~P6XsM7aj&z1~*0qj)KIZ;#AK(Q0l=J zWu73XdGIiJf;`7koLQ9$3UzOg$9xzW)R4760}0uG(1;geU|{g$Ven@NU}O-_P0UVp z&d*CuED6sn$#BlkD=taQD=9`Z45|~0VH^xWj12OwMMbHlMG965u81U@nU|bjRFs-r zlB&nf5CTi1;FyAk4i`f(Ll_T3I70*@16O)#iEnCgabkKZdW1u*7h+&!@MC9)W@O-j zhjd|SDkB36Br)>)Wag#%mF6a;7J(BqBLhorVrCvFo}-bH57acxFh&O6;F84TY~REJ zuzGfeBt`~dEJ_&}xPtRbi;`2_GILTH83d7S*8@dABZGibett=DNl{{fZ)!M zyR^U>Gf0p`P&9^A7NlZPjvP|{;F8iBIfX!ta8At03C=7@wPs}C@yyFhEppCDEG|wh zW@jj3WKhNM6E>%^Gn6ng$l+JY$iN2i7lR^06ay0j2rw})f{JtoMur#$1_oIMMg~R( z1_oBG?F@_?85kHC8Dbe27}&sqj0~I%aSZVgrA(6;m>IYj7#I&|?VH8Gvx$LSh<6(U z|Hj=6qLJGf#C^1Ub@tgYo3V(p$Sz_`(h+4bvSO8FwPIs3W0z#x#vrj8WO+IR0|N^K z1A{gL1A`U=1A{ID1A`R<1A{&T149%8149J^1A~_&n~>Z#28EdnX3S>n%NYzL*@RTU zd^HvjUqO;hNDa&vV+HXAB-w;Czt-RSXOa7eJOVFfcHKy$Gt%7#Q*y7#OB# zYwu*xVq`eLV6ctB2$`L*gTZtsgC!Hga)$ZH;$|EuJWg#np;D0%|HOkv+m4D34F7(#b3M1o~EGB7fTF|J`;&k)SO1di=8 z23c^turjbR@G`J5@G)>Ph%xXoXfg0H>|qdOxW^#G@Q^{2;XQ*G!(Rq*Ms5ZPMm`2< zMgs;JMq>tfMn?t(Mt=rH#t;T2#yAEQ#vBG!#(V}1###nm#%2aR#$E<}#w84fjB6Oo z7}qnHFm7NlW!%qT&XB;sz+l55%=e#xpMjN~A(5Ryo1Gz%k&%JnAA=)1gCskHBqKjR zKaZS>j>=yKEk?$l3<5tGcz-akDzH1TGX(Q9Ff$}GFfcGNq%fp1Ffi~jFfn8?Ffycp W$qa@91_lN$21bTLhGK?N21x)^&MvC} literal 0 HcmV?d00001 diff --git a/DEV3.2/Piles/tableau/Arithmetique.java b/DEV3.2/Piles/tableau/Arithmetique.java new file mode 100644 index 0000000..d90c8c0 --- /dev/null +++ b/DEV3.2/Piles/tableau/Arithmetique.java @@ -0,0 +1,56 @@ +public class Arithmetique { + + public static void main(String[] args) { + if (args.length == 0) { + System.out.println("Veuillez fournir une expression en notation polonaise inversée."); + return; + } + + // Utilisation de l'implémentation PileTableau pour la pile + Pile stack = new PileTableau<>(); + + try { + for (String token : args) { + switch (token) { + case "+": + // Addition + stack.push(stack.pop() + stack.pop()); + break; + case "-": + // Soustraction (attention à l'ordre) + int b = stack.pop(); + int a = stack.pop(); + stack.push(a - b); + break; + case "x": + // Multiplication + stack.push(stack.pop() * stack.pop()); + break; + case "/": + // Division (attention à l'ordre) + b = stack.pop(); + a = stack.pop(); + if (b == 0) { + throw new ArithmeticException("Division par zéro"); + } + stack.push(a / b); + break; + default: + // Si ce n'est pas un opérateur, alors c'est un nombre + stack.push(Integer.parseInt(token)); + break; + } + } + + // Le résultat final doit être le seul élément restant sur la pile + if (stack.size() == 1) { + System.out.println("= " + stack.pop()); + } else { + System.out.println("Erreur : Expression incorrecte."); + } + + } catch (Exception e) { + System.out.println("Erreur lors de l'évaluation de l'expression : " + e.getMessage()); + } + } +} diff --git a/DEV3.2/Piles/tableau/Pile.class b/DEV3.2/Piles/tableau/Pile.class new file mode 100644 index 0000000000000000000000000000000000000000..95c37e29a26b7984a8a076eecf44a1432e11ab5a GIT binary patch literal 306 zcmX^0Z`VEs1_mbvVRi;4Mh2FE%$!tq1{OvJfvm)`ME#t^ymWp4q^#8B5=I7=g3{s) zMg~z0A9Oiu%`ip=&fv`Syu^~yqEto(HjNNhupo0megPwch=wMn9!3UM4b2c&Yeoi^ z;>@a4Mh0dLO;1J!_RM0}+=7xyFh7csLBqz?3RANkrVt|oS8#r5QF5wVW=<+211HEU zdLWmwF)}bRFf)Jv3kxFyD+3z?BLh1F0|OHS2MZ$uCj%Fp&&|Tfz{9}H015#<27a&_ Mh)MwlK`>7U04GpCM*si- literal 0 HcmV?d00001 diff --git a/DEV3.2/Piles/tableau/Pile.java b/DEV3.2/Piles/tableau/Pile.java new file mode 100644 index 0000000..7e11a14 --- /dev/null +++ b/DEV3.2/Piles/tableau/Pile.java @@ -0,0 +1,7 @@ +// Interface représentant une pile +public interface Pile { + void push(E element); // Ajoute un élément en haut de la pile + E pop(); // Retire et retourne l'élément en haut de la pile + int size(); // Retourne la taille de la pile + boolean isEmpty(); // Vérifie si la pile est vide +} diff --git a/DEV3.2/Piles/tableau/PileTableau.class b/DEV3.2/Piles/tableau/PileTableau.class new file mode 100644 index 0000000000000000000000000000000000000000..a7c4f93264237bc3383a447cc24c65908e579666 GIT binary patch literal 1198 zcmX^0Z`VEs1_mbvOD+Z`24;2!79Ivx1~x_pfvm)`ME#t^ymWp4q^#8B5=I6#o6Nk- z5<5l)W)00SP6iGJPId+^9tLg(9!3W4fXtlKki?{%)WlLo2A1N?s#Hb>Mo*9`J{|^s z1_4F}j?|pg+|<01VnznxXdiUrt+^OD7=(Bjgh7_`rREiv7Nt5T79=KTmQ;eIM0ps* z7{nPF*fWb=a|=o;!LEp6XOLuMkVly1nUj;6o|qF{l30@JT9KSuP?DLS$H5@Y$ROa8 zs8EoZld6zfT%u5xnUc!IAi*FD@~j*qgQy0QdxA@fGV{`{HN&_V6c`lQ8I*V!lo?b| zLL|7dxFj`~k%2R@s3@^AIlrKikwFXD3`me!dm7$bv#r=Mqt zr=w52vtxjxvu8*oBLlBmKZ7WP0Muy)42%qh3`S71;u%=LX6b2d zV-T6iz`L74B2q|dJA=%AxWOzbQCk_TA08=1<|4mwvLs7iQ9pZfeDmFp}J$CA*BP- z4RZg!1q@1Hnl)oD0~6Rw%-YOgksS>3TH4TffEW((n+5|9gBF80gEoU2gARi>gC5v2 SW(G!397AH;jKLfnAQk|6^W1*` literal 0 HcmV?d00001 diff --git a/DEV3.2/Piles/tableau/PileTableau.java b/DEV3.2/Piles/tableau/PileTableau.java new file mode 100644 index 0000000..fc5eef9 --- /dev/null +++ b/DEV3.2/Piles/tableau/PileTableau.java @@ -0,0 +1,47 @@ +// Classe PileTableau utilisant un tableau pour stocker les éléments +public class PileTableau implements Pile { + private static final int INITIAL_CAPACITY = 10; + private E[] elements; + private int size = 0; + + @SuppressWarnings("unchecked") + public PileTableau() { + elements = (E[]) new Object[INITIAL_CAPACITY]; // Création du tableau initial + } + + @Override + public void push(E element) { + ensureCapacity(); // Redimensionne si nécessaire + elements[size++] = element; // Ajoute l'élément en haut de la pile + } + + @Override + public E pop() { + if (isEmpty()) { + throw new IllegalStateException("La pile est vide"); + } + E element = elements[--size]; // Récupère l'élément en haut de la pile + elements[size] = null; // Supprime la référence pour éviter les fuites de mémoire + return element; + } + + @Override + public int size() { + return size; + } + + @Override + public boolean isEmpty() { + return size == 0; + } + + // Redimensionne le tableau si nécessaire + private void ensureCapacity() { + if (size == elements.length) { + @SuppressWarnings("unchecked") + E[] newElements = (E[]) new Object[elements.length * 2]; // Double la capacité + System.arraycopy(elements, 0, newElements, 0, elements.length); + elements = newElements; + } + } +}