Zastanawiasz się jaki język programowania wybrać?

|
                  
                

Spis technologii

(Omawianych na tej stronie)

C

JavaScript Node.js Angular React Vue TypeScript Phaser

C++ Qt Unreal Engine

Scala

Java LibGDX Spring

Kotlin

Groovy

Ruby Ruby on Rails

C# Unity ASP.NET

Swift

Python Django

Go

PHP Laravel Symfony WordPress

Rust

R

---

Scratch SQL HTML i CSS Bootstrap Jekyll

// JavaScript
function binarySearch(array, x) {
  let start = 0;
  let end = array.length - 1;
  while (start <= end) {
    const middle = Math.floor((start + end) / 2);
    if (array[middle] === x) {
      return middle;
    }
    if (array[middle] > x) {
      end = middle - 1;
    } else {
      start = middle + 1;
    }
  }
  return -1;
}

const library = ['Algorytmy', 'Czysty kod', 'Harry Potter', 'Illuminati', 'Wzorce projektowe', '...'];
/* Dla wyszukiwania binarnego
 tablica musi być posortowana rosnąco */

const x = 'Illuminati';
const foundXAt = binarySearch(library, x);

console.log('Znaleziono "' + x + '" na pozycji ' + foundXAt);
// Znaleziono "Illuminati" na pozycji 3
// C++
#include <iostream>
using namespace std;

int binarySearch(string array[], string x) {
  int start = 0;
  int end = sizeof(array) - 1;
  while (start <= end) {
    int middle = (start + end) / 2;
    if (array[middle] == x) {
      return middle;
    }
    if (array[middle] > x) {
      end = middle - 1;
    } else {
      start = middle + 1;
    }
  }
  return -1;
}

int main() {
  string library[] = {"Algorytmy", "Czysty kod", "Harry Potter", "Illuminati", "Wzorce projektowe", "..."};
  /* Dla wyszukiwania binarnego
  tablica musi być posortowana rosnąco */

  string x = "Illuminati";
  int foundXat = binarySearch(library, x);

  cout << "Znaleziono \"" + x + "\" na pozycji " + to_string(foundXat)<< endl;
  // Znaleziono "Illuminati" na pozycji 3
}
// PHP
function binarySearch($array, $x) {
  $start = 0;
  $end = sizeof($array) - 1;
  while ($start <= $end) {
    $middle = floor(($start + $end) / 2);
    if ($array[$middle] === $x) {
      return $middle;
    }
    if ($array[$middle] > $x) {
      $end = $middle - 1;
    } else {
      $start = $middle + 1;
    }
  }
  return -1;
}

$library = array("Algorytmy", "Czysty kod", "Harry Potter", "Illuminati", "Wzorce projektowe", "...");
/* Dla wyszukiwania binarnego
tablica musi być posortowana rosnąco */

$x = "Illuminati";
$foundXAt = binarySearch($library, $x);

echo "Znaleziono \" $x \" na pozycji $foundXAt";
//Znaleziono "Illuminati" na pozycji 3
// Java
public class BinarySearch {
  public static int binarySearch(String[] array, String x) {
    int start = 0;
    int end = array.length - 1;
    while (start <= end) {
      int middle = (start + end) / 2;
      if (array[middle].equals(x)) {
        return middle;
      }
      if(array[middle].compareTo(x) > 0) {
        end = middle-1;
      } else {
        start = middle+1;
      }
    }
    return -1;
  }

  public static void main(String[] args) {
    String[] library = {"Algorytmy", "Czysty kod", "Harry Potter", "Illuminati", "Wzorce projektowe", "..."};
    /* Dla wyszukiwania binarnego
    tablica musi być posortowana rosnąco */

    String x = "Illuminati";
    int foundXAt = binarySearch(library, x);

    System.out.println("Znaleziono \"" + x + "\" na pozycji " + foundXAt);
    // Znaleziono "Illuminati" na pozycji 3
  }
}
# Ruby
def binarySearch(a, x)
  startAt = 0
  endAt = a.length - 1
  while startAt <= endAt
    middle = ((startAt + endAt) / 2).floor
    if a[middle] == x
      return middle
    else
      if a[middle] > x
        endAt = middle - 1
      else
        startAt = middle + 1
      end
    end
  end
  return -1
end

library = ["Algorytmy", "Czysty kod", "Harry Potter", "Illuminati", "Wzorce projektowe", "..."]
# Dla wyszukiwania binarnego
# tablica musi być posortowana rosnąco

x = "Illuminati";
foundXAt = binarySearch(library, x);
puts("Znaleziono \"" + x + "\" na pozycji " + foundXAt.to_s)
# Znaleziono "Illuminati" na pozycji 3
# Python
def binarySearch(array, x) :
  start = 0
  end = len(array) - 1
  while start <= end :
    middle = (start+end) // 2
    if array[middle] == x :
      return middle
    if array[middle] > x :
      end = middle - 1
    else:
      start = middle + 1
  return -1

library = ["Algorytmy", "Czysty kod", "Harry Potter", "Illuminati", "Wzorce projektowe", "..."]
# Dla wyszukiwania binarnego
# tablica musi być posortowana rosnąco

x = "Illuminati"
foundXAt = binarySearch(library, x)

print("Znaleziono \"" + x + "\" na pozycji " + str(foundXAt))
# Znaleziono "Illuminati" na pozycji 3
// C
#include <stdio.h>

int binarySearch(char *array[], char *x, int Asize){
  int start = 0;
  int end = Asize - 1;
  while(start <= end) {
    int middle = (start + end) / 2;
    if (strcmp(array[middle], x) == 0) {
      return middle;
    }
    if (strcmp(array[middle], x) > 0) {
      end = middle - 1;

    } else {
      start = middle + 1;

    }
  }
  return -1;
}

int main(void) {
  char *array[6] = {"Algorytmy", "Czysty kod", "Harry Potter", "Illuminati", "Wzorce projektowe", "..."};
  /* Dla wyszukiwania binarnego
  tablica musi być posortowana rosnąco */

  int arrSize = sizeof(array) / sizeof(array[0]);
  char x[] = "Illuminati";
  int foundXAt = binarySearch(array, x, arrSize);

  printf("Znaleziono \"%s\" na pozycji %d \n", x, foundXAt);
  // Znaleziono "Illuminati" na pozycji 3
}
// Swift
func binarySearch(array: [String], x: String) -> Int {
  var start = 0;
  var end = array.count - 1;
  while (start<=end) {
    var middle = (start+end) / 2;
    if (array[middle] == x) {
      return middle;
    }
    if (array[middle] > x) {
      end = middle - 1;
    } else {
      start = middle + 1;
    }
  }
  return -1;

}

var library = ["Algorytmy", "Czysty kod", "Harry Potter", "Illuminati", "Wzorce projektowe", "..."];
/* Dla wyszukiwania binarnego
tablica musi być posortowana rosnąco */

var x = "Illuminati";
var foundXAt = binarySearch(array: library, x: x);

print("Znaleziono \"" + String(x) + "\" na pozycji " + String(foundXAt));
// Znaleziono "Illuminati" na pozycji 3
// C♯
using System;
class MainClass {
  public static int binarySearch(String[] array, String x){
    int start = 0;
    int end = array.Length - 1;
    while(start <= end) {
      int middle = (start+end) / 2;
      if (array[middle] == x) {
        return middle;
      }
      if(array[middle].CompareTo(x) > 0){
        end = middle - 1;
      } else {
        start = middle + 1;
      }
    }
    return -1;
  }

  public static void Main(String[] args) {
    String[] library = {"Algorytmy", "Czysty kod" ,"Harry Potter" , "Illuminati", "Wzorce projektowe", "..."};
    /* Dla wyszukiwania binarnego
    tablica musi być posortowana rosnąco */

    String x = "Illuminati";
    int foundXAt = binarySearch(library, x);

    Console.WriteLine("Znaleziono \"" + x + "\" na pozycji " + foundXAt);
    // Znaleziono "Illuminati" na pozycji 3
  }
}
# R
binarySearch <- function (array, x){
  start <- 0;
  end <- length(array) - 1;
  while (start <= end) {
    middle <- floor((start+end) / 2);
    if (array[middle] == x) {
      return(middle);
    }
    if(array[middle] > x){
      end = middle - 1;
    }
    else{
      start = middle + 1;
    }
  }
  return -1;
}

library <- c("Algorytmy", "Czysty kod", "Harry Potter", "Illuminati", "Wzorce projektowe", "...");
# Dla wyszukiwania binarnego
# tablica musi być posortowana rosnąco

x = "Illuminati";
foundXAt = binarySearch(library, x);

print(paste("Znaleziono ", x, " na pozycji ", foundXAt));
# Znaleziono "Illuminati" na pozycji 4
// Kotlin
fun binarySearch(array: Array<String>, x: String): Int {
    var start = 0
    var end = array.size - 1
    while (start <= end) {
        val middle = (start + end) / 2
        if (array[middle] == x) {
            return middle
        }
        if (array[middle] > x) {
            end = middle - 1
        } else {
            start = middle + 1
        }
    }
    return -1
}

fun main() {
    val library = arrayOf("Algorytmy", "Czysty kod", "Harry Potter", "Illuminati", "Wzorce projektowe", "...")
    /* Dla wyszukiwania binarnego
    tablica musi być posortowana rosnąco */

    val x = "Illuminati"
    val foundXAt = binarySearch(library, x)

    println("""Znaleziono "$x" na pozycji $foundXAt""")
    // Znaleziono "Illuminati" na pozycji 3
}
// Scala
object BinarySearch extends App {
  def binarySearch(array: Array[String], x: String): Int = {
    var start = 0
    var end = array.size - 1
    while (start <= end) {
        val middle = (start + end) / 2
        if (array(middle) == x) {
            return middle
        }
        if (array(middle) > x) {
            end = middle - 1
        } else {
            start = middle + 1
        }
    }
    return -1
  }

  val library = Array("Algorytmy", "Czysty kod", "Harry Potter", "Illuminati", "Wzorce projektowe", "...")
  /* Dla wyszukiwania binarnego
  tablica musi być posortowana rosnąco */

  val x = "Illuminati"
  val foundXAt = binarySearch(library, x)

  println(s"""Znaleziono "$x" na pozycji $foundXAt""")
  // Znaleziono "Illuminati" na pozycji 3
}
fn binary_search(array: &[&str], x: &str) -> isize {
    let mut start = 0;
    let mut end = array.len() as isize - 1;

    while start <= end {
        let middle = (start + end) / 2;
        if array[middle as usize] == x {
            return middle;
        }
        if array[middle as usize] > x {
            end = middle - 1;
        } else {
            start = middle + 1;
        }
    }
    -1
}

fn main() {
    let library = ["Algorytmy", "Czysty kod", "Harry Potter", "Illuminati", "Wzorce projektowe", "..."];
    /* Dla wyszukiwania binarnego
       tablica musi być posortowana rosnąco */

    let x = "Illuminati";
    let found_x_at = binary_search(&library, x);

    println!("Znaleziono \"{}\" na pozycji {}", x, found_x_at);
    // Znaleziono "Illuminati" na pozycji 3
}
class BinarySearch {
    static int binarySearch(String[] array, String x) {
        int start = 0
        int end = array.length - 1
        while (start <= end) {
            int middle = (start + end) / 2
            if (array[middle].equals(x)) {
                return middle
            }
            if (array[middle].compareTo(x) > 0) {
                end = middle - 1
            } else {
                start = middle + 1
            }
        }
        return -1
    }

    static void main(String[] args) {
        String[] library = ["Algorytmy", "Czysty kod", "Harry Potter", "Illuminati", "Wzorce projektowe", "..."]
        // Dla wyszukiwania binarnego
        // tablica musi być posortowana rosnąco

        String x = "Illuminati"
        int foundXAt = binarySearch(library, x)

        println("Znaleziono \"${x}\" na pozycji ${foundXAt}")
        // Znaleziono "Illuminati" na pozycji 3
    }
}
import "fmt"

func binarySearch(array []string, x string) int {
    start := 0
    end := len(array) - 1

    for start <= end {
        middle := (start + end) / 2
        if array[middle] == x {
            return middle
        }
        if array[middle] > x {
            end = middle - 1
        } else {
            start = middle + 1
        }
    }
    return -1
}

func main() {
    library := []string{"Algorytmy", "Czysty kod", "Harry Potter", "Illuminati", "Wzorce projektowe", "..."}
    // Dla wyszukiwania binarnego tablica musi być posortowana rosnąco

    x := "Illuminati"
    foundXAt := binarySearch(library, x)

    fmt.Printf("Znaleziono \"%s\" na pozycji %d\n", x, foundXAt)
    // Znaleziono "Illuminati" na pozycji 3
}

Zobacz polecane kursy i książki