Poniżej znajdują się zadania do samodzielnych ćwiczeń studentów. Tematy zadań oraz ich opisy wskazują na to co dany program ma realizować. Student winien zmierzyć się sam wpierw z zadaniem próbując je wykonać i dopiero wtedy, gdy mu się to nie uda zajrzeć do proponowanego, przykładowego rozwiązania.
Spis treści
Operowanie stringami
1. Zrealizuj program, który pobiera od użytkownika zdanie, a następnie zamienia wszystkie litery na duże.
import java.util.Scanner;
public class UpperCase {
static String zd, wynik="";
public static void main(String[] args) {
Scanner kl=new Scanner(System.in);
System.out.println("Podaj zdanie : "); zd=kl.nextLine();
for (int ix=0; ix<zd.length(); ix++) {
if (zd.charAt(ix)>='a' && zd.charAt(ix)<='z' )
wynik+=(char)(zd.charAt(ix)-('a'-'A')); else wynik+=zd.charAt(ix);
}
System.out.println(wynik);
}
}
2. Zrealizuj program, który pobiera od użytkownika zdanie, a następnie wypisuje heksadecymalnie je w kodach ASCII.
import java.util.Scanner;
public class Text2HexASCII {
static String text2HexASCII(String zd) {
int LB,HB;
String wynik="";
for (int ix=0; ix<zd.length(); ix++) {
LB = zd.charAt(ix)%16;
HB = (zd.charAt(ix)-LB)/16;
//wynik=Integer.toHexString(HB)+Integer.toHexString(LB);
wynik+=Integer.toHexString(zd.charAt(ix)); }
return wynik;
}
public static void main(String[] args) {
Scanner kl=new Scanner(System.in);
System.out.println("Podaj zdanie : ");
System.out.println(text2HexASCII(kl.nextLine()));
}
}
3. Zrealizuj program, który łączy obie powyższe funkcjonalności aby wyświetlać kod heksadecymalny dużymi literami.
import java.util.Scanner;
public class Text2HexASCII {
static String text2HexASCII(String zd) {
int LB,HB;
String wynik="";
for (int ix=0; ix<zd.length(); ix++) {
LB = zd.charAt(ix)%16;
HB = (zd.charAt(ix)-LB)/16;
//wynik=Integer.toHexString(HB)+Integer.toHexString(LB);
wynik+=Integer.toHexString(zd.charAt(ix));
}
return wynik;
}
static String toUpperCase(String zd) {
String wynik="";
for (int ix=0; ix<zd.length(); ix++) {
if (zd.charAt(ix)>='a' && zd.charAt(ix)<='z' )
wynik+=(char)(zd.charAt(ix)-('a'-'A')); else wynik+=zd.charAt(ix);
}
return wynik;
}
public static void main(String[] args) {
Scanner kl=new Scanner(System.in);
System.out.println("Podaj zdanie : ");
System.out.println(toUpperCase(text2HexASCII(kl.nextLine())));
}
}
Tablice
1. Tablica Stringów powinna zawierać 50 pól wypełnionych 3-znakowymi literałami (tylko duże litery od A do Z) np.: ABA, MXE, LAZ, XYZ, YTU… itp.
Napisz program zawierający procedurę wygenerowania tych literałów i zainicjalizowania tablicy tymi wartościami. Następnie należy wyświetlić alfabet (posortowany alfabetycznie) użyty w literałach (czyli podać tylko te litery, które faktycznie znajdują się w tablicy, jeśli np. litera C nie występuje, to nie należy jej podawać!) oraz obok każdej litery wyświetlić ilość jej wystąpień w tablicy.
import java.util.Random;
public class TablicaLiteralow{
public static void main (String params[]) {
final int liter=3, alfabetLicznosc=256; //ustawianie wartości brzegowych.
String tab [] = new String[50]; //wymagana tablica
int alfabet []=new int[alfabetLicznosc]; //tablica zliczająca wystąpienia
for (int i=0; i<alfabet.length; i++) alfabet[i]=0; // zerowanie tablicy zliczającej,
// domyślnie zbędne, bo wartości w tablicy
// przyjmą wartość początkową = 0
Random r=new Random(); //uruchomienie generatora liczb pseudolosowych
int los;
for (int i=0; i<tab.length; i++) { //pętla wypełniająca tablicę literałami
tab[i]=""; // domyślnie w tablicy są null
for (int j=0;j<liter;j++) { // pętla ilości liter w literale
//los=(int)(r.nextFloat()*('Z'-'A'+1)+'A'); // losowanie litery od 'A'-'Z'
los=(Math.abs(r.nextInt())%('Z'-'A'+1)+'A'); // drugi sposób losowania
tab[i]+=(char)los; // tworzenie literału litera po literze
alfabet[los]++; // dodanie kolejnego wystąpienia litery do tablicy wystąpień
}
}
// wyświetlenie wyników:
for (int i=0;i<255;i++) if ( alfabet[i]!=0 ) System.out.printf("Litera %s wystąpiła %4d razy \n",(char)i,alfabet[i]) ;
}
}
Inny sposób jest przedstawiony poniżej. W tym przypadku nie wykorzystujemy wiedzy o ułożeniu tablicy ASCII, a sami definiujemy własny alfabet, z którego układami literały. Przy okazji w metodzie getAlphaNumericString() pokazany jest sposób korzystania z klasy StringBuilder oraz korzystamy z metody .random biblioteki Math, która zwraca nam wartość typu double z zakresu \langle0,1) lub zapisując dokładniej z uwagi na mantysę liczby użytego typu double: 0 ÷ 1-2^{-53} .
public class TablicaLiteralowII{
static final String ALL_LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; //<-- zadeklarowany alfabet
public static void main(String[] argumenty) {
int dlugoscStringa=3;
String[] strTab = new String[50];
for (int i = 0; i < strTab.length; i++)
System.out.println( strTab[i] = getAlphaNumericString(dlugoscStringa) );
System.out.println("-----Analiza liczebności---------");
char[] chars = ALL_LETTERS.toCharArray();
int countLetters;
for (char letter: chars) {
countLetters = 0;
for (String str : strTab)
for (int j = 0; j < str.length(); j++)
if (str.charAt(j) == letter) countLetters++;
if(countLetters != 0){
System.out.println(letter + " - " + countLetters);
}
}
}
static String getAlphaNumericString(int n) {
StringBuilder sb = new StringBuilder(n);
for (int i = 0; i < n; i++)
sb.append(ALL_LETTERS.charAt((int)(ALL_LETTERS.length() * Math.random())));
return sb.toString();
}
}
Kolejną metodą jest użycie HashMap’y do przygotowania wyniku.
import java.util.HashMap;
import java.util.Random;
public class LiteralyIII {
public static void main(String[] args) {
Random random = new Random();
String[] tab = new String[50];
int ileLiter = 3;
String wyraz;
for (int i = 0; i < tab.length; i++) {
wyraz = "";
for (int j = 0; j < ileLiter; j++)
wyraz += Character.toString((char) (random.nextInt('Z' - 'A') + 'A'));
System.out.println(tab[i] = wyraz);
}
HashMap<Character, Integer> hashMapa = new HashMap<>();
for (String znak : tab)
for (int i = 0; i < znak.length(); i++)
if (hashMapa.containsKey(znak.charAt(i)))
hashMapa.replace(znak.charAt(i), (hashMapa.get(znak.charAt(i)) + 1));
else hashMapa.put(znak.charAt(i), 1);
System.out.println(hashMapa);
}
}
2. Wypełnianie widowni teatru widzami.
Dwie tablice Stringów zawierają po 50 pól z imionami, jedna żeńskimi, druga męskimi (nie muszą być wszystkie pola zajęte!), program skorzysta tylko z tych pól, które są wypełnione.
Napisz program wypełniający trzecią tablicę, która jest planem widowni tak, aby wypełnić losowo wszystkie miejsca “widzami” (imiona), z założeniem że powinno być po połowie żeńskich i męskich – w “parach” siedzących obok siebie (wyjątkiem są rzędy z nieparzystą liczbą miejsc).
Wypisz wylosowane pary w rzędach, a następnie wypisz ile razy każde z imion zostało “umieszczonych” na sali.
Rozwiązanie:
Aby zrealizować ten program trzeba po pierwsze zauważyć, że mamy dwa źródła danych z imionami żeńskimi i męskimi. Będziemy na końcu programu wypisywać krotność ich użycia, więc dobrze jest już na tym etapie zaprojektować tablicę tak, aby można było umieścić w niej owe krotności.
Druga sprawa, to wypełnianie “widowni”, należy zaprojektować strukturę tablicową odwzorowującą ową widownię – będzie to tablica dwuwymiarowa o różnej wielkości w drugim wymiarze.
Teraz należy zdefiniować te struktury…
class Teatr {
public static void main(String [] r) {
String [][] imionaKobiet = new String[50][2]; //w drugim wymiarze schowamy krotność...
String [][] imionaMezczyzn = new String[50][2];
//dowolna ilość imion w tablicach wskazuje, że musimy obsłużyć puste miejsca...
//poniższe przypisanie mimo, że wygodne jest błędne!!! Bowiem to nie jest zapisanie tablicy
//wartościami, a utworzenie tablicy 3-elementowej w pierwszym przypadku i 4-elementowej
//w drugim. Adres tak stworzonych tablic jest przypisywany do naszych zmiennych
//imionaKobiet i imionaMezczyzn...
//ale to NIE SĄ już 50-elementowe tablice! Utraciliśmy pierwotną deklarację!
// Pamiętajcie o wskaźnikach!!! i o tym czym są elementy w takiej tablicy!!!
//Pamiętamy, że mieliśmy mieć tablicę 50(!)-elementową...
/*
imionaKobiet = new String[][] {{"Alicja",""},{"Małgorzata",""},{"Zofia",""}}; <---BŁĘDNIE!!!
imionaMezczyzn = new String[][] {{"Wojciech",""},{"Tomasz",""},{"Roman",""},{"Antoni",""}}; <---BŁĘDNIE!!!
*/
//tak więc musimy nieco wolniej zrealizować naszą operację wypełniania imionami...
imionaKobiet[0]=new String [] {"Alicja",""};
imionaKobiet[1]=new String [] {"Małgorzata",""};
imionaKobiet[2]=new String [] {"Zofia",""};
imionaKobiet[3]=new String [] {"Maria",""};
imionaKobiet[4]=new String [] {"Adelajda",""};
imionaKobiet[5]=new String [] {"Martyna",""};
imionaKobiet[6]=new String [] {"Krystyna",""};
imionaKobiet[7]=new String [] {"Dominika",""};
imionaKobiet[17]=new String [] {"Janina",""};
//powyżej zastosowaliśmy wygodne wypełnianie, które poprzednio było błędem, ale nie tutaj
//ponieważ każdy element tablicy imion wskazuje na null... więc nie ma póki co żadnego
// wskaźnika na tablicę Stringów (imię,krotność). To samo robimy z drugą tablicą:
imionaMezczyzn[0]=new String [] {"Wojciech",""};
imionaMezczyzn[1]=new String [] {"Adam",""};
imionaMezczyzn[2]=new String [] {"Tomasz",""};
imionaMezczyzn[3]=new String [] {"Roman",""};
imionaMezczyzn[4]=new String [] {"Antoni",""};
imionaMezczyzn[5]=new String [] {"Zdzisław",""};
imionaMezczyzn[6]=new String [] {"Karol",""};
imionaMezczyzn[7]=new String [] {"Paweł",""};
imionaMezczyzn[8]=new String [] {"Jeremiasz",""};
//Gdy już mamy zainicjalizowane tablice imion, możemy sprawdzić ich zawartość i rozmiar.
for (String[] s: imionaKobiet)
if ((s[0] != null) && (!s[0].equals("")))
System.out.printf("%s wystąpiło: %d razy \n\r", s[0], s[1].length());
for (String[] s: imionaMezczyzn)
if ((s[0] != null) && (!s[0].equals("")))
System.out.printf("%s wystąpiło: %d razy \n\r", s[0], s[1].length());
System.out.println("Rozmiar tablicy imion kobiecych to: "+imionaKobiet.length);
System.out.println("Rozmiar tablicy imion męskich to: "+imionaMezczyzn.length);
//jak widać, póki co spełniamy założenia zadania.
//===================SALA TEATRU=======================
String [][] salaTeatru = new String[17][]; //widzimy, że potrzebujemy 17 rzędów
//a w każdym rzędzie potrzebujemy tylu miejsc:
salaTeatru[0]=new String[20];
salaTeatru[1]=new String[23];
salaTeatru[2]=new String[26];
salaTeatru[3]=new String[27];
salaTeatru[4]=new String[27];
salaTeatru[5]=new String[27];
salaTeatru[6]=new String[30];
salaTeatru[7]=new String[31];
salaTeatru[8]=new String[32];
salaTeatru[9]=new String[33];
salaTeatru[10]=new String[34];
salaTeatru[11]=new String[33];
salaTeatru[12]=new String[34];
salaTeatru[13]=new String[30];
salaTeatru[14]=new String[27];
salaTeatru[15]=new String[25];
salaTeatru[16]=new String[24];
//trochę żmudnie, ale prosto odwzorowane.
//================= Program właściwy ===================
int los;
for (int i=0;i<salaTeatru.length;i++)
for (int ii=0;ii<salaTeatru[i].length;ii+=2) {
//nie możemy zakładać, ze imiona są wypełnione od początku tablicy stąd szukamy elementów
//tablicy, które przechowują ciągi niepuste!
do los = (int)(Math.random()*imionaMezczyzn.length);
while (imionaMezczyzn[los][0]==null);
//jak taki znajdziemy - przypisujemy go na widowni...
salaTeatru[i][ii]=imionaMezczyzn[los][0];
do los = (int)(Math.random()*imionaKobiet.length);
while (imionaKobiet[los][0]==null);
if (salaTeatru[i].length>ii+1) salaTeatru[i][ii+1]=imionaKobiet[los][0];
//powyżej już musimy sprawdzić, czy w rzędzie jest parzysta, czy nieparzysta liczba miejsc...
}
//===================KONIEC??===========================
// czyżby już?? Sprawdźmy to oddzielną pętlą...
for( String[] ss:salaTeatru) {
for (String s:ss) System.out.print(s+" ");
System.out.println();
}
}
}
Jeszcze nie!! Program miał wypisywać krotność imion użytych do wypełnienia sali… zmodyfikujmy go. Wystarczy dopisać dwie linie do naszej pętli programu głównego.
for (int i=0;i<salaTeatru.length;i++)
for (int ii=0;ii<salaTeatru[i].length;ii+=2) {
//nie możemy zakładać, ze imiona są wypełnione od początku tablicy stąd szukamy elementów
//tablicy, które przechowują ciągi niepuste!
do los = (int)(Math.random()*imionaMezczyzn.length);
while (imionaMezczyzn[los][0]==null);
//jak taki znajdziemy - przypisujemy go na widowni...
salaTeatru[i][ii]=imionaMezczyzn[los][0];
imionaMezczyzn[los][1]+="x"; // dopisujemy "x" na znak użycia tego imienia...
do los = (int)(Math.random()*imionaKobiet.length);
while (imionaKobiet[los][0]==null);
if (salaTeatru[i].length>ii+1) { salaTeatru[i][ii+1]=imionaKobiet[los][0];
imionaKobiet[los][1]+="x";
}
}
Teraz to już wszystko… Do sprawdzenia co mamy w tablicy imion (krotności) możemy użyć naszego kodu z początku programu. Pozwólcie, że przeniosę go na koniec. A cały program wygląda tak jak na poniższym listingu.
class Teatr {
public static void main(String [] r) {
String [][] imionaKobiet = new String[50][2];
String [][] imionaMezczyzn = new String[50][2];
imionaKobiet[0]=new String [] {"Alicja",""}; imionaKobiet[1]=new String [] {"Małgorzata",""}; imionaKobiet[2]=new String [] {"Zofia",""}; imionaKobiet[3]=new String [] {"Maria",""}; imionaKobiet[4]=new String [] {"Adelajda",""}; imionaKobiet[5]=new String [] {"Martyna",""}; imionaKobiet[6]=new String [] {"Krystyna",""}; imionaKobiet[7]=new String [] {"Dominika",""}; imionaKobiet[17]=new String [] {"Janina",""};
imionaMezczyzn[0]=new String [] {"Wojciech",""}; imionaMezczyzn[1]=new String [] {"Adam",""}; imionaMezczyzn[2]=new String [] {"Tomasz",""}; imionaMezczyzn[3]=new String [] {"Roman",""}; imionaMezczyzn[4]=new String [] {"Antoni",""}; imionaMezczyzn[5]=new String [] {"Zdzisław",""}; imionaMezczyzn[6]=new String [] {"Karol",""}; imionaMezczyzn[7]=new String [] {"Paweł",""}; imionaMezczyzn[8]=new String [] {"Jeremiasz",""};
//===================SALA TEATRU=======================
String [][] salaTeatru = new String[17][];
salaTeatru[0]=new String[20]; salaTeatru[1]=new String[23]; salaTeatru[2]=new String[26]; salaTeatru[3]=new String[27]; salaTeatru[4]=new String[27]; salaTeatru[5]=new String[27]; salaTeatru[6]=new String[30]; salaTeatru[7]=new String[31]; salaTeatru[8]=new String[32]; salaTeatru[9]=new String[33]; salaTeatru[10]=new String[34]; salaTeatru[11]=new String[33]; salaTeatru[12]=new String[34]; salaTeatru[13]=new String[30]; salaTeatru[14]=new String[27]; salaTeatru[15]=new String[25]; salaTeatru[16]=new String[24];
//================= Program właściwy ===================
int los;
for (int i=0;i<salaTeatru.length;i++)
for (int ii=0;ii<salaTeatru[i].length;ii+=2) {
do los = (int)(Math.random()*imionaMezczyzn.length);
while (imionaMezczyzn[los][0]==null);
salaTeatru[i][ii]=imionaMezczyzn[los][0]; imionaMezczyzn[los][1]+="x";
do los = (int)(Math.random()*imionaKobiet.length);
while (imionaKobiet[los][0]==null);
if (salaTeatru[i].length>ii+1) { salaTeatru[i][ii+1]=imionaKobiet[los][0];
imionaKobiet[los][1]+="x"; }
}
for( String[] ss:salaTeatru) {
for (String s:ss) System.out.print(s+" ");
System.out.println();
}
for (String[] s: imionaKobiet)
if ((s[0] != null) && (!s[0].equals("")))
System.out.printf("%s wystąpiło: %d razy \n\r", s[0], s[1].length());
for (String[] s: imionaMezczyzn)
if ((s[0] != null) && (!s[0].equals("")))
System.out.printf("%s wystąpiło: %d razy \n\r", s[0], s[1].length());
}
}
Jakie zalety ma powyższy kod??
- Można dowolnie dopisywać i kasować elementy z tablic z imionami, a program i tak użyje tylko tych wypełnionych (patrz na pozycję imienia “Janina”).
- Można rekonfigurować salę na inne rozmiary, a program i tak sobie poradzi z wypełnianiem danymi bez zmiany choćby linijki kodu.
- Warunki sprawdzają, czy nie występuje null w tablicy. Nieumiejętne użycie klauzury try-catch spowodowałoby przerwanie działania programu, a nie zagwarantuje jego poprawnej pracy.
Jakie ma wady?!
- Program umieszcza jako osoby pojedyncze (w przypadku nieparzystej liczności miejsc w rzędzie) tylko mężczyzn, ale nie narusza to warunków programu, bowiem tylko w parzystej liczności rzędach miały być umieszczane pary. Nie ma słowa o tym, kto ma być umieszczony na nieparzystym, ostatnim miejscu w rzędzie. Oczywiście wystarczy prosta modyfikacja programu, aby losowane było to miejsce pomiędzy mężczyzną, a kobietą. To już pozostawiam Wam :-).
Jak działa program? Mniej więcej to wypisuje w konsoli:
Zdzisław Alicja Zdzisław Dominika Wojciech Małgorzata Antoni Martyna Karol Adelajda Wojciech Adelajda Karol Janina Roman Dominika Jeremiasz Adelajda Zdzisław Zofia Zdzisław Alicja Antoni Alicja Roman Martyna Adam Janina Antoni Adelajda Paweł Krystyna Wojciech Adelajda Paweł Alicja Adam Alicja Adam Maria Antoni Martyna Tomasz Tomasz Adelajda Wojciech Alicja Wojciech Dominika Tomasz Martyna Jeremiasz Martyna Paweł Małgorzata Roman Dominika Roman Krystyna Zdzisław Zofia Wojciech Zofia Wojciech Alicja Adam Krystyna Tomasz Janina Antoni Małgorzata Karol Alicja Jeremiasz Małgorzata Karol Małgorzata Antoni Alicja Antoni Zofia Jeremiasz Maria Roman Małgorzata Adam Zofia Antoni Martyna Adam Janina Adam Małgorzata Tomasz Janina Antoni Roman Małgorzata Zdzisław Maria Karol Janina Paweł Adelajda Karol Krystyna Roman Dominika Adam Alicja Wojciech Maria Wojciech Małgorzata Tomasz Krystyna Tomasz Zofia Karol Janina Tomasz Martyna Tomasz Paweł Maria Jeremiasz Małgorzata Antoni Dominika Roman Janina Zdzisław Krystyna Roman Adelajda Karol Zofia Wojciech Krystyna Wojciech Martyna Roman Martyna Wojciech Krystyna Tomasz Małgorzata Wojciech Maria Antoni Zdzisław Martyna Roman Martyna Paweł Janina Adam Krystyna Karol Maria Jeremiasz Janina Karol Zofia Tomasz Małgorzata Zdzisław Martyna Adam Martyna Adam Małgorzata Roman Zofia Roman Janina Tomasz Krystyna Jeremiasz Dominika Antoni Adelajda Jeremiasz Małgorzata Paweł Martyna Karol Martyna Wojciech Zofia Paweł Zofia Paweł Adelajda Wojciech Zofia Zdzisław Alicja Adam Małgorzata Paweł Martyna Paweł Krystyna Jeremiasz Dominika Karol Maria Adam Alicja Paweł Jeremiasz Krystyna Zdzisław Maria Paweł Janina Wojciech Alicja Karol Alicja Tomasz Maria Adam Adelajda Jeremiasz Małgorzata Roman Zofia Wojciech Adelajda Roman Krystyna Wojciech Krystyna Tomasz Krystyna Adam Maria Wojciech Dominika Jeremiasz Krystyna Karol Adelajda Karol Martyna Tomasz Maria Adam Martyna Tomasz Adelajda Antoni Dominika Adam Alicja Antoni Alicja Jeremiasz Maria Wojciech Adelajda Paweł Adelajda Karol Dominika Roman Maria Jeremiasz Małgorzata Zdzisław Adelajda Antoni Małgorzata Wojciech Adam Alicja Paweł Dominika Antoni Dominika Adam Alicja Adam Maria Zdzisław Maria Tomasz Alicja Jeremiasz Małgorzata Tomasz Małgorzata Wojciech Dominika Karol Martyna Antoni Maria Antoni Dominika Zdzisław Janina Tomasz Zofia Tomasz Martyna Adam Martyna Paweł Martyna Paweł Dominika Wojciech Małgorzata Wojciech Adelajda Tomasz Martyna Jeremiasz Janina Zdzisław Janina Tomasz Maria Paweł Martyna Roman Adelajda Adam Martyna Adam Adelajda Jeremiasz Zofia Paweł Adelajda Adam Martyna Antoni Martyna Jeremiasz Paweł Krystyna Antoni Adelajda Jeremiasz Dominika Roman Małgorzata Wojciech Adelajda Wojciech Dominika Roman Małgorzata Roman Martyna Adam Alicja Antoni Martyna Tomasz Martyna Zdzisław Małgorzata Adam Alicja Karol Małgorzata Roman Krystyna Zdzisław Małgorzata Tomasz Małgorzata Antoni Adelajda Roman Martyna Roman Maria Zdzisław Janina Antoni Adelajda Roman Janina Wojciech Maria Antoni Zofia Adam Dominika Roman Janina Adam Małgorzata Antoni Krystyna Adam Dominika Zdzisław Dominika Antoni Dominika Karol Maria Wojciech Maria Tomasz Maria Wojciech Krystyna Zdzisław Alicja Antoni Martyna Paweł Alicja Wojciech Adelajda Wojciech Małgorzata Karol Janina Roman Maria Karol Janina Zdzisław Martyna Paweł Tomasz Maria Paweł Alicja Adam Dominika Tomasz Zofia Antoni Maria Antoni Małgorzata Tomasz Krystyna Wojciech Krystyna Jeremiasz Adelajda Tomasz Krystyna Zdzisław Krystyna Tomasz Dominika Tomasz Jeremiasz Janina Tomasz Alicja Paweł Dominika Tomasz Martyna Tomasz Maria Zdzisław Alicja Tomasz Adelajda Karol Zofia Wojciech Alicja Roman Zofia Paweł Małgorzata Jeremiasz Alicja Alicja wystąpiło: 28 razy Małgorzata wystąpiło: 31 razy Zofia wystąpiło: 19 razy Maria wystąpiło: 27 razy Adelajda wystąpiło: 28 razy Martyna wystąpiło: 34 razy Krystyna wystąpiło: 24 razy Dominika wystąpiło: 25 razy Janina wystąpiło: 21 razy Wojciech wystąpiło: 33 razy Adam wystąpiło: 30 razy Tomasz wystąpiło: 35 razy Roman wystąpiło: 27 razy Antoni wystąpiło: 29 razy Zdzisław wystąpiło: 23 razy Karol wystąpiło: 22 razy Paweł wystąpiło: 25 razy Jeremiasz wystąpiło: 22 razy BUILD SUCCESSFUL (total time: 0 seconds)
2. Transponowanie liczby do jej zapisu binarnego i heksadecymalnej.
Napisz program, który odbierze od użytkownika liczbę (z klawiatury), a następnie wyświetli ją w postaci binarnej i heksadecymalnej
3. Szyfrowanie tekstu kluczem numerycznym
Napisz program, który odbierze od użytkownika zdanie (z klawiatury), oraz kod numeryczny, zakoduje zdanie tym kodem, wyświetli zakodowane zdanie, a następnie dokona operacji odwrotnej wyświetlając na powrót rozkodowane zdanie.
import java.util.Scanner;
public class SzyfrowanieZdan {
//metoda dokonująca kodowania każdej literki ze stringa wykonując na niej XOR z kodem.
//z uwagi na fakt, że nie można w Java traktować stringa jak tablicy jednowymiarowej
//musimy dokonać jego transkodowania do tablicy char
static String koduj(String zd, int kod){
String zd0="";
for (char z:zd.toCharArray()) { zd0+=(char)(z^kod); }
return zd0;
}
//------------------------------------------------------------------
public static void main(String[] args) {
String zdanie;
int kod;
//-------------odczyt zdania z klawiatury---------------------------
Scanner t=new Scanner(System.in);
System.out.println("Podaj zdanie do zaszyfrowania.");
zdanie=t.nextLine();
//-------------odczyt kodu "szyfrującego"---------------------------
do
try {
System.out.print("Podaj kod szyfrowania : ");
kod=Integer.parseInt(t.nextLine());
break;
} catch (NumberFormatException handler) { System.out.println("Błędny kod, spróbuj jeszcze raz..."); }
while (1==1);
//------------uruchomienie metody szyfrującej i wypisanie -----------
//---- wartości zwracanej (zakodowanego/odkodowanego zdania----------
//-zgodnie z charakterystyką XOR pierwsze kodowanie szyfruje zdanie,-
//----------- drugie kodowanie rozszyfrowuje zdanie -----------------
System.out.println(zdanie=koduj(zdanie,kod));
System.out.println(koduj(zdanie,kod));
}
}