algoritms Flashcards
Fibonnaci algoritms
Fibonacci using Recursion:
Recursion is the simplest way to calculate Fibonacci numbers, but it can be very slow for large values of n because it recalculates the same values multiple times.
java
Copy code
public static int fibonacciRecursive(int n) {
if (n <= 1) {
return n;
} else {
return fibonacciRecursive(n - 1) + fibonacciRecursive(n - 2);
}
}
Fibonacci using Iteration (Loop):
An iterative approach is more efficient than recursion because it avoids redundant calculations by storing intermediate results in variables.
java
Copy code
public static int fibonacciIterative(int n) {
if (n <= 1) {
return n;
}
int prev = 0;
int current = 1;
for (int i = 2; i <= n; i++) {
int next = prev + current;
prev = current;
current = next;
}
return current; } Fibonacci using an Optimized Approach: The previous iterative approach can be further optimized using a constant amount of memory for any n. java Copy code public static int fibonacciOptimized(int n) {
if (n <= 1) {
return n;
}
int prev = 0;
int current = 1;
for (int i = 2; i <= n; i++) {
int next = prev + current;
prev = current;
current = next;
}
return current; } These are three common ways to calculate Fibonacci numbers. The iterative and optimized approaches are more efficient and recommended for larger values of n, while the recursive approach is more straightforward but less efficient for larger inputs.
JWT w mikroserwisach
JWT (ang. JSON Web Token) to powszechnie stosowana metoda uwierzytelniania w architekturach mikroserwisów. Jest używany do bezpiecznego przesyłania informacji w postaci obiektu JSON między różnymi podmiotami. W mikroserwisach JWT pełni kilka ważnych funkcji:
Uwierzytelnianie i Autoryzacja: Mikroserwisy często wykorzystują JWT do obsługi uwierzytelniania i autoryzacji użytkowników. Po zalogowaniu i zweryfikowaniu tożsamości, serwis generuje JWT. Ten token może zawierać role użytkownika, uprawnienia i inne potrzebne szczegóły, umożliwiając różnym usługom uwierzytelnianie i autoryzację użytkownika bez konieczności ponownego kontaktu z serwerem uwierzytelniającym.
Komunikacja Bezstanowa: Mikroserwisy często są bezstanowe, co oznacza, że nie przechowują danych sesji między żądaniami. JWT pomaga w utrzymaniu informacji sesyjnych wewnątrz tokena, co zmniejsza potrzebę przechowywania sesji czy zapytań do bazy danych.
Bezpieczna Komunikacja: Token jest cyfrowo podpisany, co zapewnia integralność tokenu i weryfikuje, że nie został zmodyfikowany. Może także być zaszyfrowany w celu dodatkowego zabezpieczenia.
Komunikacja Międzyserwisowa: JWT może być przesyłany między mikroserwisami, umożliwiając bezpieczną komunikację i zapewniając, że każdy serwis potrafi uwierzytelniać i zaufać nadawcy tokenu.
Proces ogólnie obejmuje:
Uwierzytelnianie: Kiedy użytkownik się loguje, usługa uwierzytelniająca tworzy JWT i zwraca go klientowi.
Autoryzacja: Klient dołącza JWT w nagłówku kolejnych żądań. Mikroserwisy weryfikują token, aby uwierzytelniać użytkownika i nadawać odpowiednie uprawnienia.
Implementacja JWT w mikroserwisach często wymaga użycia bibliotek lub frameworków, które obsługują generowanie, parsowanie i weryfikację JWT. Ważne jest również stosowanie środków bezpieczeństwa, takie jak ustawianie okresów ważności tokenów i odświeżanie tokenów.
Poprawnie zaimplementowane JWT oferują elastyczny, wydajny i bezpieczny sposób obsługi uwierzytelniania i autoryzacji w różnych mikroserwisach w aplikacji.
Abbreviation algoritm
package com.devs.exercises;
public class Abbreviation {
public String abbreviateSentences(String sentence) {
StringBuilder result = new StringBuilder();
String[] listOfWordsInGivenSentence = sentence.split(“ “);
for (String word : listOfWordsInGivenSentence) {
String[] subWords = word.split("-");
StringBuilder wordResult = new StringBuilder();
for (String subWord : subWords) {
if (subWord.length() >= 5 && !subWord.matches(".*[!].*")) {
String abbreviation = subWord.substring(0, 1) + (subWord.length() - 2) + subWord.substring(subWord.length() - 1);
wordResult.append(abbreviation);
} else {
wordResult.append(subWord);
}
wordResult.append("-");
}
// Remove trailing hyphen if there was one
if (wordResult.charAt(wordResult.length() - 1) == '-') {
wordResult.deleteCharAt(wordResult.length() - 1);
}
result.append(wordResult).append(" ");
}
return result.toString().trim();
} }
the longest consequitive word
package com.devs.exercises;
// Deklaracja pakietu com.devs.exercises
public class LongestConsecutiveWords {
// Deklaracja publicznej klasy LongestConsecutiveWords
public String returnLongestConsecutive(String[] strrar, int k) {
// Deklaracja publicznej metody returnLongestConsecutive, która przyjmuje tablicę stringów strrar i liczbę całkowitą k, zwraca string
String longestWord = "";
// Inicjalizacja zmiennej longestWord jako pustego stringa, będzie przechowywać najdłuższy ciąg słów
for (int i = 0; i <= strrar.length - k; i++) {
// Pętla for iterująca po tablicy strrar, od 0 do (strrar.length - k)
StringBuilder combinedWords = new StringBuilder();
// Inicjalizacja StringBuilder combinedWords, który będzie budować ciąg słów
for (int j = i; j < i + k; j++) {
// Wewnętrzna pętla for, która iteruje od bieżącego indeksu i do (i + k), łącząc kolejne słowa
combinedWords.append(strrar[j]);
// Dodanie strrar[j] do combinedWords
}
String currentCombined = combinedWords.toString();
// Konwersja combinedWords do stringa currentCombined
if (currentCombined.length() >= k && currentCombined.length() > longestWord.length()) {
// Jeśli długość currentCombined jest większa lub równa k i jest większa od długości longestWord
longestWord = currentCombined;
// Przypisanie currentCombined do longestWord, jeśli spełnia warunki
}
}
System.out.println("The longest word in the array is: " + longestWord);
// Wypisanie najdłuższego słowa znalezionego w tablicy
return longestWord;
// Zwrócenie najdłuższego ciągu słów
} }
PartSums
package com.devs.exercises;
// Deklaracja pakietu, do którego należy ta klasa.
public class PartSums {
// Definicja publicznej klasy PartSums.
public int[] addNumbersInArray(int[] ls) {
// Deklaracja publicznej metody addNumbersInArray, która przyjmuje tablicę liczb całkowitych ls i zwraca tablicę liczb całkowitych.
int sum = 0;
// Inicjalizacja zmiennej sum, która będzie przechowywać sumę elementów tablicy.
int[] result = new int[ls.length + 1];
// Tworzy nową tablicę wynikową o długości większej o 1 od tablicy ls.
for (int i = ls.length - 1; i >= 0; i--) {
// Rozpoczyna pętlę for, która przechodzi przez tablicę ls od końca do początku.
sum += ls[i];
// Dodaje wartość bieżącego elementu tablicy ls do sumy.
result[i] = sum;
// Przypisuje aktualną sumę do odpowiedniego miejsca w tablicy result.
}
result[result.length - 1] = 0;
// Ustawia ostatni element tablicy result na 0.
for (int num : result) {
// Rozpoczyna pętlę for-each, która przechodzi przez każdy element tablicy result.
System.out.print(num + " ");
// Drukuje bieżący element tablicy result, oddzielając go spacją.
}
return result;
// Zwraca tablicę result.
} }
Pyramids
import java.util.List;
public class Pyramid {
public int[][] createArrays(int number) {
int[][] numbers = new int[number][];
for (int i = 0; i < numbers.length; i++) {
numbers[i] = new int[i + 1];
for (int j = 0; j <= i; j++) {
numbers[i][j] = 1;
}
}
return numbers;
}
public void printPyramid(int[][] pyramid) {
List<List<Integer>> pyramidList = new ArrayList<>();
for (int[] row : pyramid) {
List<Integer> rowList = new ArrayList<>();
for (int num : row) {
rowList.add(num);
}
pyramidList.add(rowList);
}
System.out.println("pyramid(" + pyramid.length + ") => " + pyramidList);
} }
