logo

TechCodeview

Amazon

Array Reverse v C/C++/Java/Python/JavaScript

Reverzné pole alebo obrátiť pole znamená zmenu polohy každého čísla daného poľa na opačnú pozíciu od konca, t.j. ak je číslo na pozícii 1, potom jeho nová pozícia bude Array.length, podobne ak je číslo na pozícii 2, jeho nová pozícia bude Dĺžka poľa – 1 atď.

Array Reverse v C/C++/Java/Python/JavaScript

Ak je dané pole (alebo reťazec), úlohou je obrátiť pole/reťazec.

Príklady:

Vstup: original_array[] = {1, 2, 3} Výkon: pole_obrátené[] = {3, 2, 1}

Vstup: original_array[] = {4, 5, 1, 2}
Výkon: pole_obrátené[] = {2, 1, 5, 4}

Obsah

1. Pole Reverzne Použitie dodatočného poľa (nie na mieste):

  • Vytvorte nové pole rovnakej veľkosti ako pôvodné pole.
  • Skopírujte prvky z pôvodného poľa do nového poľa v opačnom poradí.

Nižšie je uvedená implementácia vyššie uvedeného prístupu:

C++ 
#include ; using namespace std; void reverseArrayExtraArray(int arr[], int size) {  int reversedArr[size];  for (int i = 0; i  < size; i++) {  reversedArr[i] = arr[size - i - 1];  }  // Print reversed array  cout  < < 'Reversed Array: ';  for (int i = 0; i  < size; i++) {  std::cout  < < reversedArr[i]  < < ' ';  } } int main() {  int originalArr[] = { 1, 2, 3, 4, 5 };  int size = sizeof(originalArr) / sizeof(originalArr[0]);  reverseArrayExtraArray(originalArr, size); }
C 
#include  void reverseArrayExtraArray(int arr[], int size) {  int reversedArr[size];  for (int i = 0; i  < size; i++) {  reversedArr[i] = arr[size - i - 1];  }  // Print reversed array  printf('Reversed Array: ');  for (int i = 0; i  < size; i++) {  printf('%d ', reversedArr[i]);  } } int main() {  int originalArr[] = { 1, 2, 3, 4, 5 };  int size = sizeof(originalArr) / sizeof(originalArr[0]);  reverseArrayExtraArray(originalArr, size);  return 0; }
Java 
/*package whatever //do not write package name here */ import java.io.*; public class ReverseArrayExtraArray {  public static void reverseArrayExtraArray(int[] arr)  {  int[] reversedArr = new int[arr.length];  for (int i = 0; i  < arr.length; i++) {  reversedArr[i] = arr[arr.length - i - 1];  }  // Print reversed array  System.out.print('Reversed Array: ');  for (int i : reversedArr) {  System.out.print(i + ' ');  }  }  public static void main(String[] args)  {  int[] originalArr = { 1, 2, 3, 4, 5 };  reverseArrayExtraArray(originalArr);  } }
Python 
def reverse_array_extra_array(arr): reversed_arr = arr[::-1] # Print reversed array print('Reversed Array:', end=' ') for i in reversed_arr: print(i, end=' ') # Example usage: original_arr = [1, 2, 3, 4, 5] reverse_array_extra_array(original_arr)
C# 
using System; class Program {  static void ReverseArrayExtraArray(int[] arr) {  int[] reversedArr = new int[arr.Length];  for (int i = 0; i  < arr.Length; i++) {  reversedArr[i] = arr[arr.Length - i - 1];  }  // Print reversed array  Console.Write('Reversed Array: ');  foreach (int num in reversedArr) {  Console.Write(num + ' ');  }  }  static void Main() {  int[] originalArr = {1, 2, 3, 4, 5};  ReverseArrayExtraArray(originalArr);  } }
JavaScript 
function reverseArrayExtraArray(arr) {  const reversedArr = arr.slice().reverse();  // Print reversed array  process.stdout.write('Reversed Array: ');  reversedArr.forEach(element =>process.stdout.write(prvok + ' ')); } // Príklad použitia: const originalArr = [1, 2, 3, 4, 5]; reverseArrayExtraArray(originalArr);

Výkon 
Reversed Array: 5 4 3 2 1
  • Časová zložitosť: O(n)
    • Kopírovanie prvkov do nového poľa je lineárna operácia.
  • Zložitosť pomocného priestoru: O(n)
    • Ďalší priestor sa používa na uloženie nového poľa.

2. Pole Reverzne Použitie slučky (na mieste):

  • Iterujte cez pole pomocou dva ukazovatele (začiatok a koniec).
  • Vymeňte prvky na začiatku a konci.
  • Posuňte ukazovateľ začiatku smerom ku koncu a ukazovateľ konca smerom k začiatku, kým sa navzájom nestretnú alebo neprekrížia.

obrátené číslo

Nižšie je uvedená implementácia vyššie uvedeného prístupu:

C++ 
// Iterative C++ program to reverse an array #include ; using namespace std; /* Function to reverse arr[] from start to end*/ void reverseArray(int arr[], int start, int end) {  while (start  < end) {  int temp = arr[start];  arr[start] = arr[end];  arr[end] = temp;  start++;  end--;  } } /* Utility function to print an array */ void printArray(int arr[], int size) {  for (int i = 0; i  < size; i++)  cout  < < arr[i]  < < ' ';  cout  < < endl; } /* Driver function to test above functions */ int main() {  int arr[] = { 1, 2, 3, 4, 5, 6 };  int n = sizeof(arr) / sizeof(arr[0]);  // To print original array  printArray(arr, n);  // Function calling  reverseArray(arr, 0, n - 1);  cout  < < 'Reversed array is'  < < endl;  // To print the Reversed array  printArray(arr, n);  return 0; }
C 
// Iterative C program to reverse an array #include  /* Function to reverse arr[] from start to end*/ void reverseArray(int arr[], int start, int end) {  int temp;  while (start  < end) {  temp = arr[start];  arr[start] = arr[end];  arr[end] = temp;  start++;  end--;  } } /* Utility that prints out an array on a line */ void printArray(int arr[], int size) {  int i;  for (i = 0; i  < size; i++)  printf('%d ', arr[i]);  printf('
'); } /* Driver function to test above functions */ int main() {  int arr[] = { 1, 2, 3, 4, 5, 6 };  int n = sizeof(arr) / sizeof(arr[0]);  printArray(arr, n);  reverseArray(arr, 0, n - 1);  printf('Reversed array is 
');  printArray(arr, n);  return 0; }
Java 
public class GFG {   /* Function to reverse arr[] from start to end*/  static void reverseArray(int arr[], int start, int end) {   int temp;   while (start  < end) {   temp = arr[start];   arr[start] = arr[end];   arr[end] = temp;   start++;   end--;   }   }   /* Utility that prints out an array on a line */  static void printArray(int arr[], int size) {   for (int i = 0; i  < size; i++)   System.out.print(arr[i] + ' ');   System.out.println();   }   // Driver code   public static void main(String args[]) {   int arr[] = {1, 2, 3, 4, 5, 6};   printArray(arr, 6);   reverseArray(arr, 0, 5);   System.out.print('Reversed array is 
');   printArray(arr, 6);   }  }
Python 
# Iterative python program to reverse an array # Function to reverse A[] from start to end def reverseList(A, start, end): while start  < end: A[start], A[end] = A[end], A[start] start += 1 end -= 1 # Driver function to test above function A = [1, 2, 3, 4, 5, 6] print(A) reverseList(A, 0, 5) print('Reversed list is') print(A) # This program is contributed by Pratik Chhajer
C# 
// Iterative C# program to reverse an // array using System; class GFG {  /* Function to reverse arr[] from  start to end*/  static void reverseArray(int[] arr, int start, int end)  {  int temp;  while (start  < end) {  temp = arr[start];  arr[start] = arr[end];  arr[end] = temp;  start++;  end--;  }  }  /* Utility that prints out an  array on a line */  static void printArray(int[] arr, int size)  {  for (int i = 0; i  < size; i++)  Console.Write(arr[i] + ' ');  Console.WriteLine();  }  // Driver function  public static void Main()  {  int[] arr = { 1, 2, 3, 4, 5, 6 };  printArray(arr, 6);  reverseArray(arr, 0, 5);  Console.Write('Reversed array is 
');  printArray(arr, 6);  } } // This code is contributed by Sam007
JavaScript 
// Iterative Javascript program to reverse an array  /* Function to reverse arr[] from start to end*/ function reverseArray(arr,start,end)  {   while (start  < end)   {   var temp = arr[start];   arr[start] = arr[end];   arr[end] = temp;   start++;   end--;   }  }  /* Utility function to print an array */ function printArray(arr,size)  {  for (var i = 0; i  < size; i++){  console.log(arr[i]);  }  }  /* Driver function to test above functions */  var arr= [1, 2, 3, 4, 5, 6];   var n = 6;   // To print original array   printArray(arr, n);     // Function calling   reverseArray(arr, 0, n-1);     console.log('Reversed array is');   printArray(arr, n);
PHP 
 // Iterative PHP program  // to reverse an array  /* Function to reverse  $arr from start to end*/ function reverseArray(&$arr, $start, $end) { while ($start  < $end) { $temp = $arr[$start]; $arr[$start] = $arr[$end]; $arr[$end] = $temp; $start++; $end--; } } /* Utility function to  print an array */ function printArray(&$arr, $size) { for ($i = 0; $i  < $size; $i++) echo $arr[$i] . ' '; echo '
'; } // Driver code  $arr = array(1, 2, 3, 4, 5, 6); // To print original array  printArray($arr, 6); // Function calling  reverseArray($arr, 0, 5); echo 'Reversed array is' .'
'; // To print the Reversed array  printArray($arr, 6); // This code is contributed  // by ChitraNayal  ?>

Výkon 
1 2 3 4 5 6 Reversed array is 6 5 4 3 2 1
  • Časová zložitosť: O(n)
    • Slučka prebieha cez polovicu poľa, takže je lineárna vzhľadom na veľkosť poľa.
  • Zložitosť pomocného priestoru: O(1)
    • Obrátenie na mieste, čo znamená, že nezaberá ďalší priestor.

3. Reverzné vstavané metódy poľa (nie na mieste):

  • Použite vstavané metódy ako reverse> v Pythone alebo Array.Reverse> v jazyku C#.

Nižšie je uvedená implementácia vyššie uvedeného prístupu:

C++ 
#include  // for std::reverse #include  int main() {  int originalArray[] = { 1, 2, 3, 4, 5 };  int length  = sizeof(originalArray) / sizeof(originalArray[0]);  // Using inbuilt method in C++  std::reverse(originalArray, originalArray + length);  // Print the reversed array  for (int i = 0; i  < length; i++) {  std::cout  < < originalArray[i]  < < ' ';  }  return 0; }
Java 
/*package whatever //do not write package name here */ import java.util.Arrays; public class ArrayReverse {  public static void main(String[] args)  {  int[] originalArray = { 1, 2, 3, 4, 5 };  // Using inbuilt method in Java  int[] reversedArray = new int[originalArray.length];  for (int i = 0; i  < originalArray.length; i++) {  reversedArray[i]  = originalArray[originalArray.length - 1  - i];  }  // Print the reversed array  System.out.println(Arrays.toString(reversedArray));  } }
Python 
original_array = [1, 2, 3, 4, 5] # Using inbuilt method in Python reversed_array = list(reversed(original_array)) # Print the reversed array print(reversed_array)
C# 
using System; class Program {  static void Main()  {  int[] originalArray = { 1, 2, 3, 4, 5 };  // Using inbuilt method in C#  Array.Reverse(originalArray);  // Print the reversed array  foreach(int num in originalArray)  {  Console.Write(num + ' ');  }  } }
JavaScript 
let originalArray = [1, 2, 3, 4, 5]; // Using inbuilt method in JavaScript let reversedArray = originalArray.slice().reverse(); // Print the reversed array console.log(reversedArray);

Výkon 
5 4 3 2 1
  • Časová zložitosť: O(n) The reverse> metóda má zvyčajne lineárnu časovú zložitosť.
  • Zložitosť pomocného priestoru: O(n)
    • Ďalší priestor sa používa na uloženie obráteného poľa.

4. Pole reverzná rekurzia (na mieste alebo mimo miesta):

  • Definujte rekurzívnu funkciu, ktorá berie pole ako vstup.
  • Vymeňte prvý a posledný prvok.
  • Rekurzívne zavolajte funkciu so zvyšným podpolom.

Nižšie je uvedená implementácia vyššie uvedeného prístupu:

C++ 
// Recursive C++ program to reverse an array #include ; using namespace std; /* Function to reverse arr[] from start to end*/ void reverseArray(int arr[], int start, int end) {  if (start>= koniec) návrat;  int temp = arr[start];  arr[začiatok] = arr[koniec];  arr[koniec] = teplota;  // Volanie rekurzívnej funkcie reverseArray(arr, začiatok + 1, koniec - 1); } /* Pomocná funkcia na tlač poľa */ void printArray(int arr[], int veľkosť) { for (int i = 0; i < size; i++)  cout  < < arr[i]  < < ' ';  cout  < < endl; } /* Driver function to test above functions */ int main() {  int arr[] = { 1, 2, 3, 4, 5, 6 };  // To print original array  printArray(arr, 6);  // Function calling  reverseArray(arr, 0, 5);  cout  < < 'Reversed array is'  < < endl;  // To print the Reversed array  printArray(arr, 6);  return 0; }
C 
// Recursive C program to reverse an array #include ; /* Function to reverse arr[] from start to end*/ void reverseArray(int arr[], int start, int end) {  int temp;  if (start>= koniec) návrat;  temp = arr[štart];  arr[začiatok] = arr[koniec];  arr[koniec] = teplota;  reverseArray(arr, začiatok + 1, koniec - 1); } /* Pomôcka, ktorá vypíše pole na riadok */ void printArray(int arr[], int size) { int i;  pre (i = 0; i < size; i++)  printf('%d ', arr[i]);  printf('
'); } /* Driver function to test above functions */ int main() {  int arr[] = { 1, 2, 3, 4, 5, 6 };  printArray(arr, 6);  reverseArray(arr, 0, 5);  printf('Reversed array is 
');  printArray(arr, 6);  return 0; }
Java 
/*package whatever //do not write package name here */ import java.io.*; class ReverseArray {  /* Function to reverse arr[] from start to end*/  static void reverseArray(int arr[], int start, int end)  {  int temp;  if (start>= koniec) návrat;  temp = arr[štart];  arr[začiatok] = arr[koniec];  arr[koniec] = teplota;  reverseArray(arr, začiatok + 1, koniec - 1);  } /* Nástroj, ktorý vytlačí pole na riadku */ static void printArray(int arr[], int size) { for (int i = 0; i < size; i++)  System.out.print(arr[i] + ' ');  System.out.println('');  }  /*Driver function to check for above functions*/  public static void main(String[] args)  {  int arr[] = { 1, 2, 3, 4, 5, 6 };  printArray(arr, 6);  reverseArray(arr, 0, 5);  System.out.println('Reversed array is ');  printArray(arr, 6);  } } /*This article is contributed by Devesh Agrawal*/
Python 
# Recursive python program to reverse an array # Function to reverse A[] from start to end def reverseList(A, start, end): if start>= koniec: návrat A[začiatok], A[koniec] = A[koniec], A[začiatok] reverseList(A, začiatok+1, koniec-1) # Funkcia ovládača na testovanie nad funkciou A = [1, 2, 3 , 4, 5, 6] print(A) reverseList(A, 0, 5) print('Obrátený zoznam je') print(A) # Tento program vytvoril Pratik Chhajer
C# 
// C# program to reverse an array using System; class GFG {  /* Function to reverse arr[]  from start to end*/  static void reverseArray(int[] arr, int start, int end)  {  int temp;  if (start>= koniec) návrat;  temp = arr[štart];  arr[začiatok] = arr[koniec];  arr[koniec] = teplota;  reverseArray(arr, začiatok + 1, koniec - 1);  } /* Nástroj, ktorý vytlačí pole na riadku */ static void printArray(int[] arr, int veľkosť) { for (int i = 0; i < size; i++)  Console.Write(arr[i] + ' ');  Console.WriteLine('');  }  // Driver Code  public static void Main()  {  int[] arr = { 1, 2, 3, 4, 5, 6 };  printArray(arr, 6);  reverseArray(arr, 0, 5);  Console.WriteLine('Reversed array is ');  printArray(arr, 6);  } } // This code is contributed by Sam007
JavaScript 
// Recursive Javascript program to reverse an array  /* Function to reverse arr[] from start to end*/ function reverseArray(arr,start,end)  {   var temp = arr[start];   arr[start] = arr[end];   arr[end] = temp;    // Recursive Function calling   if (start+1   PHP   
 // Recursive PHP program to reverse an array /* Function to reverse $arr[] from $start to $end */ function reverseArray(&$arr, $start, $end) { if ($start>= $koniec) { return; } $temp = $arr[$začiatok]; $arr[$začiatok] = $arr[$koniec]; $arr[$end] = $temp; // Volanie rekurzívnej funkcie reverseArray($arr, $start + 1, $end - 1); } /* Pomocná funkcia na tlač poľa */ funkcia printArray(&$arr, $veľkosť) { for ($i = 0; $i < $size; $i++) { echo $arr[$i] . ' '; } echo '
'; } // Driver function to test above functions $arr = array(1, 2, 3, 4, 5, 6); // To print original array  printArray($arr, 6); // Function calling  reverseArray($arr, 0, 5); echo 'Reversed array is' . '
'; // To print the Reversed array  printArray($arr, 6); ?> 
    
  Výkon   
1 2 3 4 5 6 Reversed array is 6 5 4 3 2 1 
  
     
  •     Časová zložitosť:     O(n). Rekurzia prechádza každým prvkom raz, takže je lineárna.  
    •  
  •     Zložitosť pomocného priestoru:     O(n) pre non-in-place, O(log n) pre in-place (kvôli rekurznému zásobníku).  
    •  
 
    5. Obrátený zásobník poľa (nie na mieste):     
 
     
  •  Zatlačte každý prvok poľa do zásobníka.  
    •  
  •  Vyberte prvky zo zásobníka a vytvorte obrátené pole.  
    •  
 
 Nižšie je uvedená implementácia vyššie uvedeného prístupu:  
C++   
#include ; #include ; #include ; void reverseArrayUsingStack(int arr[], int size) {  std::stack stoh;  // Vloženie prvkov do zásobníka pre (int i = 0; i < size; i++) {  stack.push(arr[i]);  }  // Pop elements from the stack to reverse the array  for (int i = 0; i  < size; i++) {  arr[i] = stack.top();  stack.pop();  } } int main() {  int arr[] = { 1, 2, 3, 4, 5 };  int size = sizeof(arr) / sizeof(arr[0]);  reverseArrayUsingStack(arr, size);  std::cout  < < 'Reversed Array: ';  for (int i = 0; i  < size; i++) {  std::cout  < < arr[i]  < < ' ';  }  return 0; } 
  C   
#include ; #include ; #define MAX_SIZE 100 struct Stack {  int arr[MAX_SIZE];  int top; }; void push(struct Stack* stack, int element) {  if (stack->top == MAX_SIZE - 1) { printf('Pretečenie zásobníka
');  návrat;  } stack->arr[++stack->top] = prvok; } int pop(struct Stack* stack) { if (stack->top == -1) { printf('Stack Underflow
');  exit(1);  } return stack->arr[stack->top--]; } void reverseArrayUsingStack(int arr[], int size) { struct Stack stack;  stack.top = -1;  // Vloženie prvkov do zásobníka pre (int i = 0; i < size; i++) {  push(&stack, arr[i]);  }  // Pop elements from the stack to reverse the array  for (int i = 0; i  < size; i++) {  arr[i] = pop(&stack);  } } int main() {  int arr[] = { 1, 2, 3, 4, 5 };  int size = sizeof(arr) / sizeof(arr[0]);  reverseArrayUsingStack(arr, size);  printf('Reversed Array: ');  for (int i = 0; i  < size; i++) {  printf('%d ', arr[i]);  }  return 0; } 
  Java   
/*package whatever //do not write package name here */ import java.util.Stack; public class ReverseArrayUsingStack {  public static void reverseArrayUsingStack(int[] arr)  {  Stack zásobník = nový zásobník ();  // Vloženie prvkov do zásobníka for (prvok int : arr) { zásobník.push(prvok);  } // Vyberie prvky zo zásobníka, aby sa pole obrátilo (int i = 0; i < arr.length; i++) {  arr[i] = stack.pop();  }  }  public static void main(String[] args)  {  int[] arr = { 1, 2, 3, 4, 5 };  reverseArrayUsingStack(arr);  System.out.print('Reversed Array: ');  for (int element : arr) {  System.out.print(element + ' ');  }  } } 
  Python   
def reverse_array_using_stack(arr): stack = [] # Push elements onto the stack for element in arr: stack.append(element) # Pop elements from the stack to reverse the array for i in range(len(arr)): arr[i] = stack.pop() # Example usage: arr = [1, 2, 3, 4, 5] reverse_array_using_stack(arr) print('Reversed Array:', arr) 
  C#   
using System; using System.Collections.Generic; class Program {  static void ReverseArrayUsingStack(int[] arr)  {  Stack zásobník = nový zásobník ();  // Vloženie prvkov do zásobníka foreach(int element in arr) { stack.Push(element); } // Vyberie prvky zo zásobníka, aby sa pole obrátilo (int i = 0; i < arr.Length; i++) {  arr[i] = stack.Pop();  }  }  static void Main()  {  int[] arr = { 1, 2, 3, 4, 5 };  ReverseArrayUsingStack(arr);  Console.Write('Reversed Array: ');  foreach(int element in arr)  {  Console.Write(element + ' ');  }  } } 
  JavaScript   
function reverseArrayUsingStack(arr) {  let stack = [];    // Push elements onto the stack  for (let i = 0; i  < arr.length; i++) {  stack.push(arr[i]);  }  // Pop elements from the stack to reverse the array  for (let i = 0; i  < arr.length; i++) {  arr[i] = stack.pop();  } } // Example usage: let arr = [1, 2, 3, 4, 5]; reverseArrayUsingStack(arr); console.log('Reversed Array:', arr); 
    
  Výkon   
Reversed Array: 5 4 3 2 1 
  
     
  •     Časová zložitosť:     O(n)  
       
    •  Zatlačenie a vysunutie každého prvku na/z stohu vyžaduje lineárny čas.  
      •  
     
    •  
  •     Zložitosť pomocného priestoru:     O(n)  
       
    •  Ďalší priestor slúži na uloženie stohu.  
      •  
     
    •  
 
 6. Dvojukazový prístup  
 
     
  •  Nastavte začiatok na 0 a koniec na veľkosť – 1.  
    •  
  •  Vymeňte prvky, kým sa ukazovatele nestretnú: Keď je začiatok kratší ako koniec, vymeňte arr[začiatok] za arr[koniec].  
    •  
  •  Vymeňte arr[start] za arr[end].  
    •  
  •  Začiatok zvýšenia a koniec zníženia.  
    •  
  •  Pokračujte vo vymieňaní a presúvaní ukazovateľov, až kým nezačnú krížikovať koniec.  
    •  
C++   
#include  void reverseArrayTwoPointer(int arr[], int size) {  int start = 0;  int end = size - 1;  while (start  < end) {  // Swap elements at start and end positions  int temp = arr[start];  arr[start] = arr[end];  arr[end] = temp;  // Move start forward and end backward  start++;  end--;  } } int main() {  int arr[] = { 1, 2, 3, 4, 5 };  int size = sizeof(arr) / sizeof(arr[0]);  reverseArrayTwoPointer(arr, size);  std::cout  < < 'Reversed Array: ';  for (int i = 0; i  < size; i++) {  std::cout  < < arr[i]  < < ' ';  }  return 0; } 
  Java   
public class ReverseArray {    public static void reverseArrayTwoPointer(int[] arr) {  int start = 0;  int end = arr.length - 1;  while (start  < end) {  // Swap elements at start and end positions  int temp = arr[start];  arr[start] = arr[end];  arr[end] = temp;  // Move start forward and end backward  start++;  end--;  }  }  public static void main(String[] args) {  int[] arr = { 1, 2, 3, 4, 5 };  reverseArrayTwoPointer(arr);  System.out.print('Reversed Array: ');  for (int i = 0; i  < arr.length; i++) {  System.out.print(arr[i] + ' ');  }  } } // This code is contributed by Shivam 
    
    Výkon:     
  
Reversed Array: 5 4 3 2 1 
 
    Časová zložitosť:     O(n) – Tento algoritmus iteruje pole raz, pričom pre každý prvok vykoná konštantný počet operácií, čo vedie k lineárnej časovej zložitosti.  
  
    Priestorová zložitosť:     O(1) – Algoritmus obráti pole na mieste bez použitia akýchkoľvek ďalších dátových štruktúr, čím si vyžaduje konštantný priestor bez ohľadu na veľkosť vstupného poľa.

Zdieľať

Mohlo By Sa Vám Páčiť

Inline funkcie v C++

Inline funkcie v C++

Zaujatosť a odchýlka v strojovom učení

Zaujatosť a odchýlka v strojovom učení

Najlepšie Články

Kategórie

Blog Konverzia Java Matematika Kolekcie Java Rozdiely Java Reťazec

Zaujímavé Články