# data[].attributes.attachment_link.readable_text
If your app has constraints not well-served by existing frameworks, you prefer to build your own framework, or you just want to learn the basics of a React app, you can build a React app from scratch.

Deep Dive

Consider using a framework
Show Details

Starting from scratch is an easy way to get started using React, but a major tradeoff to be aware of is that going this route is often the same as building your own adhoc framework. As your requirements evolve, you may need to solve more framework-like problems that our recommended frameworks already have well developed and supported solutions for.

For example, if in the future your app needs support for server-side rendering (SSR), static site generation (SSG), and/or React Server Components (RSC), you will have to implement those on your own. Similarly, future React features that require integrating at the framework level will have to be implemented on your own if you want to use them.

Our recommended frameworks also help you build better performing apps. For example, reducing or eliminating waterfalls from network requests makes for a better user experience. This might not be a high priority when you are building a toy project, but if your app gains users you may want to improve its performance.

Going this route also makes it more difficult to get support, since the way you develop routing, data-fetching, and other features will be unique to your situation. You should only choose this option if you are comfortable tackling these problems on your own, or if you're confident that you will never need these features.

For a list of recommended frameworks, check out Creating a React App.

Step 1: Install a build tool

The first step is to install a build tool like vite, parcel, or rsbuild. These build tools provide features to package and run source code, provide a development server for local development and a build command to deploy your app to a production server.

Vite is a build tool that aims to provide a faster and leaner development experience for modern web projects.

npm create vite@latest my-app -- --template react

Vite is opinionated and comes with sensible defaults out of the box. Vite has a rich ecosystem of plugins to support fast refresh, JSX, Babel/SWC, and other common features. See Vite's React plugin or React SWC plugin and React SSR example project to get started.

Vite is already being used as a build tool in one of our recommended frameworks: React Router.

Parcel combines a great out-of-the-box development experience with a scalable architecture that can take your project from just getting started to massive production applications.

npm install --save-dev parcel

Parcel supports fast refresh, JSX, TypeScript, Flow, and styling out of the box. See Parcel's React recipe to get started.

Rsbuild is an Rspack-powered build tool that provides a seamless development experience for React applications. It comes with carefully tuned defaults and performance optimizations ready to use.

npx create-rsbuild --template react

Rsbuild includes built-in support for React features like fast refresh, JSX, TypeScript, and styling. See Rsbuild's React guide to get started.

Note

Step 2: Build Common Application Patterns

The build tools listed above start off with a client-only, single-page app (SPA), but don't include any further solutions for common functionality like routing, data fetching, or styling.

The React ecosystem includes many tools for these problems. We've listed a few that are widely used as a starting point, but feel free to choose other tools if those work better for you.

Routing determines what content or pages to display when a user visits a particular URL. You need to set up a router to map URLs to different parts of your app. You'll also need to handle nested routes, route parameters, and query parameters. Routers can be configured within your code, or defined based on your component folder and file structures.

Routers are a core part of modern applications, and are usually integrated with data fetching (including prefetching data for a whole page for faster loading), code splitting (to minimize client bundle sizes), and page rendering approaches (to decide how each page gets generated).

We suggest using:

Fetching data from a server or other data source is a key part of most applications. Doing this properly requires handling loading states, error states, and caching the fetched data, which can be complex.

Purpose-built data fetching libraries do the hard work of fetching and caching the data for you, letting you focus on what data your app needs and how to display it. These libraries are typically used directly in your components, but can also be integrated into routing loaders for faster pre-fetching and better performance, and in server rendering as well.

Note that fetching data directly in components can lead to slower loading times due to network request waterfalls, so we recommend prefetching data in router loaders or on the server as much as possible! This allows a page's data to be fetched all at once as the page is being displayed.

If you're fetching data from most backends or REST-style APIs, we suggest using:

If you're fetching data from a GraphQL API, we suggest using:

Code-splitting is the process of breaking your app into smaller bundles that can be loaded on demand. An app's code size increases with every new feature and additional dependency. Apps can become slow to load because all of the code for the entire app needs to be sent before it can be used. Caching, reducing features/dependencies, and moving some code to run on the server can help mitigate slow loading but are incomplete solutions that can sacrifice functionality if overused.

Similarly, if you rely on the apps using your framework to split the code, you might encounter situations where loading becomes slower than if no code splitting were happening at all. For example, lazily loading a chart delays sending the code needed to render the chart, splitting the chart code from the rest of the app. Parcel supports code splitting with React.lazy. However, if the chart loads its data after it has been initially rendered you are now waiting twice. This is a waterfall: rather than fetching the data for the chart and sending the code to render it simultaneously, you must wait for each step to complete one after the other.

Splitting code by route, when integrated with bundling and data fetching, can reduce the initial load time of your app and the time it takes for the largest visible content of the app to render ( Largest Contentful Paint).

For code-splitting instructions, see your build tool docs:

Since the build tool you select only support single page apps (SPAs) you'll need to implement other rendering patterns like server-side rendering (SSR), static site generation (SSG), and/or React Server Components (RSC). Even if you don't need these features at first, in the future there may be some routes that would benefit SSR, SSG or RSC.

Single-page apps (SPA) load a single HTML page and dynamically updates the page as the user interacts with the app. SPAs are easier to get started with, but they can have slower initial load times. SPAs are the default architecture for most build tools.

Streaming Server-side rendering (SSR) renders a page on the server and sends the fully rendered page to the client. SSR can improve performance, but it can be more complex to set up and maintain than a single-page app. With the addition of streaming, SSR can be very complex to set up and maintain. See Vite's SSR guide.

Static site generation (SSG) generates static HTML files for your app at build time. SSG can improve performance, but it can be more complex to set up and maintain than server-side rendering. See Vite's SSG guide.

React Server Components (RSC) lets you mix build-time, server-only, and interactive components in a single React tree. RSC can improve performance, but it currently requires deep expertise to set up and maintain. See Parcel's RSC examples.

Your rendering strategies need to integrate with your router so apps built with your framework can choose the rendering strategy on a per-route level. This will enable different rendering strategies without having to rewrite your whole app. For example, the landing page for your app might benefit from being statically generated (SSG), while a page with a content feed might perform best with server-side rendering.

Using the right rendering strategy for the right routes can decrease the time it takes for the first byte of content to be loaded ( Time to First Byte), the first piece of content to render ( First Contentful Paint), and the largest visible content of the app to render ( Largest Contentful Paint).

These are just a few examples of the features a new app will need to consider when building from scratch. Many limitations you'll hit can be difficult to solve as each problem is interconnected with the others and can require deep expertise in problem areas you may not be familiar with.

If you don't want to solve these problems on your own, you can get started with a framework that provides these features out of the box.

# data[].attributes.attachment_link.description
The library for web and native user interfaces

# data[].attributes.body
Plik ten ma być w katalogi src wraz z plikiem index.html

# data[].attributes.body
const express = require("express");

const app = express();

const path = require("path");

const port = 3000;

app.use(express.static(path.join(__dirname, "dane")));

app.listen(port, ()=>{ console.log(`Serwer działa na http://localhost:${port}`); });

# data[].attributes.body
Nazwa użytkownika: @Kacper17381

# data[].attributes.body
@oliwierknysak

# data[].attributes.body
Andrii Hordiichuk 3p

# data[].attributes.attachment_link.description
Build and deploy software collaboratively with the power of AI without spending a second on setup.

# data[].attributes.attachment_link.description
Run Kotlin code live in your browser. Write and run code in 50+ languages online with Replit, a powerful IDE, compiler, & interpreter.

# data[].attributes.body
@filipadamoski91

# data[].attributes.body
replit @vitalikdibrov02

# data[].attributes.body
var zdanie = prompt("Podaj zdanie: ").toLowerCase();

var litery = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','r','s','t','u','w','y','z'];

var panagram = true;

for(var i = 0; i < litery.length; i++){

if(!zdanie.includes(litery[i])){

panagram = false;

break;

}

}

console.log(zdanie);

if(panagram){

console.log(`Zdanie jest panagramem`);

}

else console.log("Zdanie nie jest panagramem");

# data[].attributes.body
Kacper Tatar

# data[].attributes.attachment_link.readable_text
Ćwiczenie 1

fun hello(): String {
    return "Hello World!"
}
fun main() {
    println(hello())
}


Ćwiczenie 2

fun LiczbaArmstronga(liczba: Int): Boolean {
    val cyfry = liczba.toString().toCharArray()
    var sum = 0
    for (digit in cyfry) {
        sum += Math.pow(digit.toString().toInt().toDouble(), cyfry.size.toDouble()).toInt()
    }
    return sum == liczba
}

fun main() {
    val liczba = 153
    if (LiczbaArmstronga(liczba)) {
        println("$liczba jest liczbą Armstronga.")
    } else {
        println("$liczba nie jest liczbą Armstronga.")
    }
}


Ćwiczenie 3

fun kod(tekst: String): String {
    val tekstZnormalizowany = tekst.replace("[^a-zA-Z]".toRegex(), "").toLowerCase()
    val length = tekstZnormalizowany.length
    var kolumny = 1
    while (kolumny * kolumny < length) {
        kolumny++
    }
    val wiersze = (length + kolumny - 1) / kolumny
    val zakodowanyTekst = StringBuilder()
    for (i in 0 until kolumny) {
        for (j in 0 until wiersze) {
            val index = i + j * kolumny
            if (index < length) {
                zakodowanyTekst.append(tekstZnormalizowany[index])
            } else {
                zakodowanyTekst.append(' ')
            }
        }
        zakodowanyTekst.append('\n')
    }
    return zakodowanyTekst.toString()
}

fun main() {
    val tekst = "If man was meant to stay on the ground, god would have given us roots."
    val zakodowany = kod(tekst)
    println(zakodowany)
}

-----------------------------------------------------------------------------------------------

object CryptoSquare {
    fun ciphertext(tekst: String): String {
        val tekstZnormalizowany = tekst.replace("[^a-zA-Z0-9]".toRegex(), "").toLowerCase()
        
        val dlugosc = tekstZnormalizowany.length
        val kolumny = Math.ceil(Math.sqrt(dlugosc.toDouble())).toInt()
        val wiersze = (dlugosc + kolumny - 1) / kolumny
        
        val tekstZakodowany = StringBuilder()
        
        for (i in 0 until kolumny) {
            for (j in 0 until wiersze) {
                val index = i + j * kolumny
                if (index < dlugosc) {
                    tekstZakodowany.append(tekstZnormalizowany[index])
                } else {
                    tekstZakodowany.append(' ')
                }
            }
            tekstZakodowany.append('\n')
        }
        
        return "Długość to $dlugosc, pierwiastek to $kolumny:\n$tekstZakodowany"
    }
}

fun main() {
    val tekst = "If man was meant to stay on the ground, god would have given us roots."
    val x = CryptoSquare.ciphertext(tekst)
    println(x)
}

# data[].attributes.body
fun main(){

val y = 1901

if(y!=null){

if(y%4==0){

println("Ten rok był rokiem przestępnym.")

}

else{

println("Ten rok nie był rokiem przestępnym.")

}

}

}

# data[].attributes.headline
Ćwiczenie 2 z lekcji z dnia 27.11.2024 Hanna Hollek

# data[].attributes.subject
Ćwiczenie 2 z lekcji z dnia 27.11.2024 Hanna Hollek

# data[].attributes.attachment_link.readable_text
fun isArmstrongNumber(number: Int): Boolean {
    val digits = number.toString().map { it.toString().toInt() }
    val power = digits.size
    val sumOfPowers = digits.sumOf { Math.pow(it.toDouble(), power.toDouble()).toInt() }
    return sumOfPowers == number
}

fun main() {
    val numbersToCheck = listOf(15, 100, 25, 78)
    for (number in numbersToCheck) {
        if (isArmstrongNumber(number)) {
            println("$number jest liczbÄ Armstronga")
        } else {
            println("$number nie jest liczbÄ Armstronga")
        }
    }
}

# data[].attributes.attachment_link.readable_text
import kotlin.random.Random

fun czyJestDoskonala(number: Int): Boolean {
    if (number < 2) return false 
    
    var sum = 1 

    for (i in 2..number / 2) {
        if (number % i == 0) {
            sum += i
        }
    }

    return sum == number
}

fun main() {
    val losowaLiczba = Random.nextInt(1, 1000)
    println("Wylosowana liczba: $losowaLiczba")

    if (czyJestDoskonala(losowaLiczba)) {
        println("$losowaLiczba jest liczbÄ doskonaÅÄ.")
    } else {
        println("$losowaLiczba nie jest liczbÄ doskonaÅÄ.")
    }
}

# data[].attributes.attachment_link.readable_text
ćwiczenie 1:

fun hello(): String { 
    return "Hello World!" 
} 

fun zabawa_glowna() { 
    println(hello()) 
}

fun main() {
    zabawa_glowna()
}

ćwiczenie 2:

fun isArmstrongNumber(number: Int): Boolean {
    
    val digits = number.toString().map { it.toString().toInt() }
    val numberOfDigits = digits.size

    
    val sum = digits.fold(0) { acc, digit -> acc + Math.pow(digit.toDouble(), numberOfDigits.toDouble()).toInt() }

    
    return sum == number
}

fun main() {
    
    val testNumbers = listOf(9, 10, 153, 154)
    
    testNumbers.forEach { number ->
        println("$number is an Armstrong number: ${isArmstrongNumber(number)}")
    }
}

ćwiczenie 3:

fun isPangram(sentence: String): Boolean {
    
    val lowerCaseSentence = sentence.toLowerCase()

    
    val alphabet = ('a'..'z').toSet()

    
    val lettersInSentence = lowerCaseSentence.filter { it in alphabet }

  
    return lettersInSentence.toSet() == alphabet
}

fun main() {
    val sentence1 = "The quick brown fox jumps over the lazy dog"
    val sentence2 = "Hello World"

    println("Is the first sentence a pangram? ${isPangram(sentence1)}")
    println("Is the second sentence a pangram? ${isPangram(sentence2)}")
}


# data[].attributes.attachment_link.readable_text
fun main() {
    println("podaj rok:")
    val rok = 33

    if (czyprzystepny(rok)) {
        println("$rok jest rokiem przestÄpnym")
    } else {
        println("$rok nie jest rokiem przestÄpnym")
    }
}

fun czyprzystepny(rok: Int): Boolean {
    return (rok % 4 == 0 && rok % 100 != 0) || rok % 400 == 0
}

# data[].attributes.attachment_link.readable_text
// kotlin cw 8 Bartosz Sikorski




fun main() {
    val liczba = 14 

    val sumaAlikwotowa = obliczSumÄAlikwotowÄ(liczba)

    when {
        sumaAlikwotowa == liczba -> println("$liczba jest liczbÄ doskonaÅÄ.")
        sumaAlikwotowa > liczba -> println("$liczba jest liczbÄ obfitÄ.")
        sumaAlikwotowa < liczba -> println("$liczba jest liczbÄ niedostatecznÄ.")
    }
}

fun obliczSumÄAlikwotowÄ(liczba: Int): Int {
    var suma = 0
    for (i in 1 until liczba) {
        if (liczba % i == 0) {
            suma += i
        }
    }
    return suma
}

# data[].attributes.headline
Vlad Shestakov Ćwiczenia 4 , 9, 10. KOTLIN

# data[].attributes.subject
Vlad Shestakov Ćwiczenia 4 , 9, 10. KOTLIN

# data[].attributes.body
Fabian Dratwiński

# data[].attributes.attachment_link.readable_text
fun scrabbleScore(word: String): Int {
    // Mapa wartości liter
    val letterValues = mapOf(
        'A' to 1, 'E' to 1, 'I' to 1, 'O' to 1, 'U' to 1, 'L' to 1, 'N' to 1, 'R' to 1, 'S' to 1, 'T' to 1,
        'D' to 2, 'G' to 2,
        'B' to 3, 'C' to 3, 'M' to 3, 'P' to 3,
        'F' to 5, 'H' to 5, 'V' to 5, 'W' to 5, 'Y' to 5,
        'K' to 5,
        'J' to 10, 'X' to 10, 'Q' to 10, 'Z' to 10
    )

    // Inicjalizacja zmiennej do przechowywania wyniku
    var score = 0

    // Oblicz punkty dla każdego znaku w słowie
    for (letter in word.uppercase()) { // Zamieniamy na wielkie litery, aby porównanie było jednoznaczne
        score += letterValues.getOrDefault(letter, 0) // Dodajemy wartość litery, jeśli istnieje w mapie
    }

    return score
}

// Przykład użycia
fun main() {
    val word = "Skibidi"
    println("Wartość słowa \"$word\" wynosi ${scrabbleScore(word)} punktów.")
}

# data[].attributes.headline
Zadanie liczby naturalne (poprawiona wersja)

# data[].attributes.subject
Zadanie liczby naturalne (poprawiona wersja)

# data[].attributes.body
Oliwier Knysak KL. III p

# data[].attributes.attachment_link.readable_text
fun main() {
    // Przykład użycia: losowanie liczby N z przedziału
    val N = (1..100).random() // Można zmienić zakres na dowolny przedział
    println("Wylosowana liczba N: $N")
    
    val result = calculateDifference(N)
    
    // Obliczenie sumy kwadratów i kwadratu sumy
    val sumOfSquares = (1..N).sumOf { it * it }
    val sum = (1..N).sum()
    val squareOfSum = sum * sum
    
    // Wypisanie wyników
    println("Suma kwadratów: $sumOfSquares")
    println("Kwadrat sumy: $squareOfSum")
    println("Różnica: $result")
}

// Funkcja obliczająca różnicę między kwadratem sumy a sumą kwadratów
fun calculateDifference(N: Int): Int {
    // Kwadrat sumy: (1 + 2 + ... + N)²
    val sum = (1..N).sum()
    val squareOfSum = sum * sum
    
    // Suma kwadratów: 1² + 2² + ... + N²
    val sumOfSquares = (1..N).sumOf { it * it }
    
    // Zwrócenie różnicy
    return squareOfSum - sumOfSquares
}

# data[].attributes.attachment_link.readable_text
fun sumOfSquares(n: Int): Int {
    var sum = 0
    for (i in 1..n) {
        sum += i * i
    }
    return sum
}
fun squareOfSum(n: Int): Int {
    var sum = 0
    for (i in 1..n) {
        sum += i
    }
    return sum * sum
}

fun difference(n: Int): Int {
    return squareOfSum(n) - sumOfSquares(n)
}

fun main() {
    println(difference(6))
}

# data[].attributes.body
fun main() {

val letterScores = mapOf(

'A' to 1, 'E' to 1, 'I' to 1, 'O' to 1, 'U' to 1, 'L' to 1, 'N' to 1, 'R' to 1, 'S' to 1, 'T' to 1,

'D' to 2, 'G' to 2,

'B' to 3, 'C' to 3, 'M' to 3, 'P' to 3,

'F' to 5, 'H' to 5, 'V' to 5, 'W' to 5, 'Y' to 5,

'K' to 5,

'J' to 10, 'X' to 10, 'Q' to 10, 'Z' to 10

)

println("Podaj słowo:")

val word = readLine()?.uppercase() ?: ""

var totalScore = 0

for (char in word) {

val score = letterScores[char] ?: 0

totalScore += score

println("$score punkt(ów) za $char")

}

println("Całkowita wartość słowa \"$word\" wynosi $totalScore punktów.")

}

# data[].attributes.body
fun main() {

println("Podaj liczbę N:")
val n = readLine()?.toIntOrNull() ?: return println("Nieprawidłowa wartość.")

val sum = (1..n).sum()

val squareOfSum = sum sum

val sumOfSquares = (1..n).sumOf { it it }

val difference = squareOfSum - sumOfSquares

println("Kwadrat sumy pierwszych $n liczb wynosi: $squareOfSum")
println("Suma kwadratów pierwszych $n liczb wynosi: $sumOfSquares")
println("Różnica wynosi: $difference")
}

# data[].attributes.attachment_link.readable_text
fun obliczWartoscSlowa(slowo: String): Int {
    val wartosciLiter = mapOf(
        'a' to 1, 'e' to 1, 'i' to 1, 'o' to 1, 'u' to 1, 'l' to 1, 'n' to 1, 'r' to 1, 's' to 1, 't' to 1,
        'd' to 2, 'g' to 2,
        'b' to 3, 'c' to 3, 'm' to 3, 'p' to 3,
        'f' to 5, 'h' to 5, 'v' to 5, 'w' to 5, 'y' to 5,
        'k' to 5,
        'j' to 10, 'x' to 10, 'q' to 10, 'z' to 10
    )

    var sumaPunktow = 0

    for (litera in slowo) {
        sumaPunktow += wartosciLiter[litera] ?: 0
    }

    return sumaPunktow
}

fun main() {
    val slowo = "kabriolet"
    val wynik = obliczWartoscSlowa(slowo)
    println("WartoÅÄ sÅowa \"$slowo\" to $wynik punktÃ³w.")
}

										2 zadanie
fun wynik(N: Int): Int {
    val suma = (N  * (N + 1)) / 2

    val sumakwadratow = (N * (N + 1) * (2 * N + 1)) / 6

    return suma * suma - sumakwadratow
}

fun main() {
    val N = 10		
    println(wynik(N))	
}

# data[].attributes.body
function difference(N) {

const sum = (N * (N + 1)) / 2; // Suma pierwszych N liczb naturalnych

const squareOfSum = sum * sum; // Kwadrat sumy

const sumOfSquares = (N (N + 1) (2 * N + 1)) / 6; // Suma kwadratów pierwszych N liczb naturalnych

return squareOfSum - sumOfSquares; // Różnica

}

const N = Math.floor(Math.random() * 100) + 1; // Losowa liczba z przedziału 1-100

console.log(`Różnica dla N = ${N}: ${difference(N)}`);

# data[].attributes.body
gra scrabble (działa w kotlinie)

# data[].attributes.attachment_link.readable_text
fun scrabble(x: String): Int { 
    val wartoscLiter = mapOf( 'A' to 1, 'E' to 1, 'I' to 1, 
                              'O' to 1, 'U' to 1, 'L' to 1, 
                              'N' to 1, 'R' to 1, 'S' to 1, 
                              'T' to 1, 'D' to 2, 'G' to 2, 
                              'B' to 3, 'C' to 3, 'M' to 3, 
                              'P' to 3, 'F' to 4, 'H' to 4,
                              'V' to 4, 'W' to 4, 'Y' to 4,
                              'K' to 5, 'J' to 10, 'X' to 10,
                              'Q' to 10, 'Z' to 10) 
    
    return x.toUpperCase().sumBy { wartoscLiter[it] ?: 0 } 
} 

fun main() { 
    val x = "DZIAÅANIE" 
    val wynik = scrabble(x) 
    println("WartoÅÄ sÅowa '$x' wynosi: $wynik punktÃ³w") 
}

# data[].attributes.body
https://replit.com/@Luter/ImpracticalLastProfessionals

# data[].attributes.body
Liczby naturalne - zadanie 2

# data[].attributes.attachment_link.readable_text
fun difference(N: Int): Int {
    val sum = (N * (N + 1)) / 2
    val squareOfSum = sum * sum
    val sumOfSquares = (N * (N + 1) * (2 * N + 1)) / 6
    return squareOfSum - sumOfSquares
}

fun getRandomInt(min: Int, max: Int): Int {
    return (min..max).random()
}

fun main() {
    val N = getRandomInt(1, 100)
    println("RÃ³Å¼nica dla N = $N: ${difference(N)}")
}

# data[].attributes.body
Dibrov Vitalii

# data[].attributes.attachment_link.readable_text
fun Sum(n: Int): Int {
    var sum = 0
    for (i in 1..n) {
        sum += i * i
    }
    return sum
}

fun square(n: Int): Int {
    var sum = 0
    for (i in 1..n) {
        sum += i
    }
    return sum * sum
}

fun difference(n: Int): Int {
    return square(n) - Sum(n)
}

fun main() {
    val n = 10
    println("RÃ³Å¼nica dla N = $n wynosi: ${difference(n)}")
}

# data[].attributes.body
Scrabble -ćwiczenie zadania 1

# data[].attributes.attachment_link.readable_text
fun main() {

    val points = mapOf(
        'A' to 1, 'E' to 1, 'I' to 1, 'O' to 1, 'U' to 1, 'L' to 1, 'N' to 1, 'R' to 1, 'S' to 1, 'T' to 1,
        'D' to 2, 'G' to 2,
        'B' to 3, 'C' to 3, 'M' to 3, 'P' to 3,
        'F' to 5, 'H' to 5, 'V' to 5, 'W' to 5, 'Y' to 5,
        'K' to 5,
        'J' to 10, 'X' to 10, 'Q' to 10, 'Z' to 10
    )


    fun calculateScrabbleScore(word: String): Int {
        var score = 0

        val upperCaseWord = word.toUpperCase()


        for (letter in upperCaseWord) {
            score += points.getOrDefault(letter, 0)
        }

        return score
    }


    val word = "Kabriolet"  
    val score = calculateScrabbleScore(word)
    println("WartoÅÄ sÅowa \"$word\" wynosi: $score punktÃ³w")
}

# data[].attributes.body
Vitalii Dibrov

# data[].attributes.attachment_link.readable_text
Solutions
Docs
Community
Teach
Play

2.0.21
JVM
Program arguments
Copy link
Share code
Run
fun main() {
    fun calculate(word: String): Int {
        val letterValues = mapOf(
            'A' to 1, 'E' to 1, 'I' to 1, 'O' to 1, 'U' to 1, 'L' to 1, 'N' to 1, 'R' to 1, 'S' to 1, 'T' to 1,
            'D' to 2, 'G' to 2,
            'B' to 3, 'C' to 3, 'M' to 3, 'P' to 3,
            'F' to 5, 'H' to 5, 'V' to 5, 'W' to 5, 'Y' to 5,
            'K' to 5,
            'J' to 10, 'X' to 10, 'Q' to 10, 'Z' to 10
        )
â
        return word.toUpperCase().sumOf { letter -> letterValues[letter] ?: 0 }
    }
â
    val word = "Kabriolet"
â
    val score = calculate(word)
â
    println("WartoÅÄ sÅowa '$word' to: $score punktÃ³w")
}
â
WartoÅÄ sÅowa 'Kabriolet' to: 15 punktÃ³w

# data[].attributes.body
Oliwier Knysak KL. III p

# data[].attributes.body
Oliwier Knysak KL. III p

# data[].attributes.headline
Zadanie 2 z dnia 25.11.2024 Hanna Hollek i Mateusz Lepiarz

# data[].attributes.subject
Zadanie 2 z dnia 25.11.2024 Hanna Hollek i Mateusz Lepiarz

# data[].attributes.attachment_link.readable_text
class Squares {
    sumOfSquares(x) {
        let suma = 0;
        for (let i = 1; i <= x; i++) {
            suma += i * i;
        }
        return suma;
    }

    squareOfSum(x) {
        let suma = 0;
        for (let i = 1; i <= x; i++) {
            suma += i;
        }
        return suma * suma;
    }

    difference(x) {
        return this.squareOfSum(x) - this.sumOfSquares(x);
    }
}

const randomX = Math.floor(Math.random() * 100) + 1;

const wynik = new Squares();
console.log(`Dla x = ${randomX}, rÃ³Å¼nica to: ${wynik.difference(randomX)}`);

# data[].attributes.headline
Zadanie 1 z dnia 25.11.2024 Hanna Hollek i Mateusz Lepiarz

# data[].attributes.subject
Zadanie 1 z dnia 25.11.2024 Hanna Hollek i Mateusz Lepiarz

# data[].attributes.attachment_link.readable_text
function obliczanieWartosci(slowo) {
    const punktacjaLiter = {
        A: 1, E: 1, I: 1, O: 1, U: 1, L: 1, N: 1, R: 1, S: 1, T: 1,
        D: 2, G: 2,
        B: 3, C: 3, M: 3, P: 3,
        F: 5, H: 5, V: 5, W: 5, Y: 5,
        K: 5,
        J: 10, X: 10, Q: 10, Z: 10
    };

    slowo = slowo.toUpperCase();

    let suma = 0;

    for (let i = 0; i < slowo.length; i++) {
        let litera = slowo[i];

        if (punktacjaLiter[litera] !== undefined) {
            suma += punktacjaLiter[litera];
        }
    }
    
    return suma;
}

const slowo = "Kieszonka";
const wynik = obliczanieWartosci(slowo);
console.log(`WartoÅÄ sÅowa "${slowo}" to: ${wynik} punktÃ³w.`);

# data[].attributes.attachment_link.readable_text
class Squares {
  squareOfSum(N) {
    let sum = 0;
    for (let i = 1; i <= N; i++) {
      sum += i;
    }
    return sum * sum;  
  }

 
  sumOfSquares(N) {
    let sum = 0;
    for (let i = 1; i <= N; i++) {
      sum += i * i;
    }
    return sum;  
  }

 
  difference(N) {
    const squareSum = this.squareOfSum(N);
    const sumSquares = this.sumOfSquares(N);
    return squareSum - sumSquares; 
  }
}


function getUserInput() {
  const N = parseInt(prompt("Wpisz liczbÄ N:"));
  
 
  if (isNaN(N) || N <= 0) {
    alert("Podaj poprawnÄ liczbÄ naturalnÄ wiÄkszÄ niÅ¼ 0.");
    return;
  }


  const squares = new Squares();
  const result = squares.difference(N);

  
  alert(`RÃ³Å¼nica dla liczby N = ${N} wynosi: ${result}`);
}

getUserInput();

# data[].attributes.headline
zadanie 1 scrable // Bartosz Sikorski, Kuba Sieminski, Kacper Tatar

# data[].attributes.subject
zadanie 1 scrable // Bartosz Sikorski, Kuba Sieminski, Kacper Tatar

# data[].attributes.attachment_link.readable_text
// Bartosz Sikorski, Kuba Sieminski, Kacper Tatar


function obliczWartoscSlowa(slowo) {
    const wartosciLiter = {
        'A': 1, 'E': 1, 'I': 1, 'O': 1, 'U': 1, 'L': 1, 'N': 1, 'R': 1, 'S': 1, 'T': 1,
        'D': 2, 'G': 2,
        'B': 3, 'C': 3, 'M': 3, 'P': 3,
        'F': 4, 'H': 4, 'V': 4, 'W': 4, 'Y': 4,
        'K': 5,
        'J': 10, 'X': 10, 'Q': 10, 'Z': 10
    };

    let suma = 0;
    for (let litera of slowo.toUpperCase()) {
        suma += wartosciLiter[litera] || 0;
    }
    return suma;
}

let slowo = "ĹźarĂłwka";
console.log("WartoĹÄ sĹowa '" + slowo + "' to: " + obliczWartoscSlowa(slowo));


// Bartosz Sikorski, Kuba Sieminski, Kacper Tatar

# data[].attributes.body
Ćwizenie 7 - scrabble

Scrabble to gra słowna, w której gracze umieszczają płytki z literami na planszy, aby utworzyć słowa. Każda litera ma wartość. Wynik słowa to suma wartości jego liter.
Twoim zadaniem jest obliczenie wartości słowa poprzez zsumowanie wartości jego liter.
Litery są wartościowane w następujący sposób:

1 pkt.: A, E, I, O, U, L, N, R, S, T

2 pkt: D, G

3 pkt: B, C, M, P

5 F, H, V, W, Y

5 pkt: K

10 pkt: J, X8Q, Z

Na przykład wyraz "Kabriolet" jest wart 15 punktów, ponieważ:

5 punktów za K

1 punkt za   A

3 punkty za  B

1 punkt za   R

1 punkt za   I

1 punkt za   O

1 punkt za   L

1 punkt za   E

1 punkt za   T

Aby wykonać zadanie nalży podać wyraz i odpowiadające mu punkty policzone w sposób automatyczny.

# data[].attributes.body
Znajdź różnicę kwadratu sumy a sumą kwadratów pierwszych N liczb naturalnych. Liczba N może zostać losowo wybrana z zadanego przedziału.
. Kwadrat sumy pierwszych dziesięciu liczb naturalnych wynosi (1 + 2 + ... + 10)² = 55² = 3025.
. Suma kwadratów pierwszych dziesięciu liczb naturalnych wynosi 1² + 2² + ... + 10² = 385.
. Różnica między kwadratem sumy a sumą kwadratów pierwszych dziesięciu liczb naturalnych wynosi 3025 - 385 = 2640.
Najważniejsze jest rozwiązanie ale postaraj się o wydajne rozwiązanie tego problemu - tym zajmiemy sie później.
Znalezienie najlepszego algorytmu dla problemu jest kluczową umiejętnością w inżynierii oprogramowania.
Poniżej propozycja rozwiązania z zastosowaniem klas (trochę przesadnie). Zaproponuj prostsze rozwiązanie.

Poniżej propozycja rozwiązania w pythonie - Twoim zadaniem jest napisanie rozwiązania w JS

        class Squares {
    var x=0
    fun sumOfSquares(x:Int):Int {
        var suma  = 0
       for (i in 1..x) {
           suma += i
    }
        return suma*suma;
    }
    fun squareOfSum(x:Int):Int {
        var suma = 0
        for (i in 1..x) {
           suma += i*i
    }
      return suma
    }

    fun difference(x:Int):Int{
     return sumOfSquares(x) - squareOfSum(x)
    }

}


fun main(args: Array<String>){
   val wynik = Squares()
   print(wynik.difference(10) )

}

# data[].attributes.body
Napisałem tyle ile zdążyłem napisać

# data[].attributes.attachment_link.readable_text
HTML:
Paliwo
Rodzaj paliwa:
1 .Benzyna

2. LPG

JavaScript: function policz() { let cena = 6.20 let zuzycie = 5 let rodzaj = document.getElementById("rodzaj").value; let dystans = document.getElementById("dystans").value; if (rodzaj==1) { cena = 6.05; zuzycie = 7.2;} if (rodzaj==2) { cena = 3.05; zuzycie = 8;} document.getElementById("cena").innerHTML = c }

# data[].attributes.attachment_link.readable_text
Paliwa
Rodzaj paliwa
Benzyna
Lpg

JAVASCRIPT function policz() { let cena = 6.20 let zuzycie = 5 let rodzaj = document.getElementById(tak).value; let dystans = document.getElementById(tak).value; if }

# data[].attributes.body
Oliwier Knysak

# data[].attributes.attachment_link.readable_text
object CryptoSquare {
    fun normalizeText(text: String): String {
        
        return text.toLowerCase()
            .filter { it.isLetterOrDigit() }
    }

    fun ciphertext(tekst: String): String {
        
        val normalizedText = normalizeText(tekst)
        val length = normalizedText.length

        
        val c = Math.ceil(Math.sqrt(length.toDouble())).toInt()
        val r = if (c * (c - 1) >= length) c - 1 else c

     
        println("DÅugoÅÄ tekstu: $length, wiersze: $r, kolumny: $c")

        
        val rows = mutableListOf<String>()
        for (i in normalizedText.indices step c) {
            val row = normalizedText.substring(i, minOf(i + c, length))
            rows.add(row)
        }

        
        println("PodziaÅ na wiersze: $rows")

       
        val encodedText = StringBuilder()
        for (i in 0 until c) {
            for (row in rows) {
                if (i < row.length) {
                    encodedText.append(row[i])
                }
            }
            encodedText.append(" ") 
        }

        return encodedText.toString().trim()
    }
}

fun main() {
  
    val text = "KaÅ¼dy czÅowiek ma prawo do wolnoÅci, rÃ³wnoÅci i szacunku."
    val encoded = CryptoSquare.ciphertext(text)
    println("Zakodowana wiadomoÅÄ: $encoded")
}

# data[].attributes.body
Więcej znajdziesz tutaj:

Pisanie testów jednostkowych w Pythonie - dobre praktyki

# data[].attributes.attachment_link.readable_text
import unittest

def int_to_roman(num):
    val = [
        1000, 900, 500, 400,
        100, 90, 50, 40,
        10, 9, 5, 4,
        1
        ]
    syms = [
        "M", "CM", "D", "CD",
        "C", "XC", "L", "XL",
        "X", "IX", "V", "IV",
        "I"
        ]
    roman_num = ''
    i = 0
    while  num > 0:
        for _ in range(num // val[i]):
            roman_num += syms[i]
            num -= val[i]
        i += 1
    return roman_num
print(int_to_roman(444))

class TestRomanNumerals(unittest.TestCase):

    def test_conversion(self):
        self.assertEqual(int_to_roman(1), 'I')
        self.assertEqual(int_to_roman(4), 'IV')
        self.assertEqual(int_to_roman(40), 'XL')
        self.assertEqual(int_to_roman(99), 'XCIX')
        self.assertEqual(int_to_roman(1000), 'M')
unittest.main()

# data[].attributes.body
Oliwier Knysak

# data[].attributes.body
Napisz skrypt, w którym utworzone zostaną 2 zmienne: imie i wiek.

Wartość zmiennych pobierz od użytkownika: input("Podaj ...: ")

Wyświetl w konsoli wynik z wykorzystaniem f-stringa czyli specjalnego sposobu formatowania danych tekstowych.

F-string tworzony jest poprzez dodanie litery f przed cudzysłowem. Dzięki temu wewnątrz wyświetlanego tekstu, czyli tego ujętego w cudzysłów, możemy wyświetlać również wartości zmiennych. Żeby to zrobić nazwę zmiennej musisz umieścić wewnątrz nawiasu klamrowego {}.

# data[].attributes.body
Naukę programowania możemy zacząć praktycznie z "marszu".

Pierwszy krok to wejście na stronę replit.com. Jest to serwis, w którym znajdziesz działające w przeglądarce kompilatory i interpretery kilkudziesięciu różnych języków.

Kompilatory i interpretery to nic innego jak specjalne programy, które tłumaczą kod, który napiszemy na język zrozumiały dla komputera.

Wśród dostępnych na replit.com języków jest zarówno HTML (z CSS i JS) jak również Python czy KOTLIN.

Dostęp do serwisu jest darmowy, ale wymaga zalogowania. Utwórz więc konto albo zaloguj się przy pomocy konta Google, Facebook, GitHub lub Apple.

Po wejściu na stronę wybierz opcję:
 "Sign up for free".

Po zalogowaniu kliknij Create Repl (lewy górny róg), a następnie z listy dostępnych języków wybierz np. Python.

Po wpisaniu “python” wyświetla się sporo różnych opcji - wybierz tę pierwszą. Następnie kliknij Create Repl

# data[].attributes.body
Napisz funkcję, która zwraca punkty zdobyte w jednym rzucie w grze w Darta.

Dart to gra, w której gracze rzucają lotkami do tarczy.

W naszej grze gracz nagradzany jest 4 różnymi liczbami punktów, w zależności od tego, gdzie wyląduje lotka:

Nasza tablica wyników rzutów z wartościami od całkowitego chybienia do utrafienia w sam środek:
Jeśli lotka wyląduje poza celem, gracz nie otrzymuje żadnych punktów (0 punktów).

Jeśli lotka wyląduje w zewnętrznym okręgu celu, gracz otrzymuje 1 punkt.
Jeśli lotka wyląduje w środkowym okręgu celu, gracz otrzymuje 5 punktów.
Jeśli lotka wyląduje w wewnętrznym okręgu celu, gracz otrzymuje 10 punktów.
Zewnętrzny okrąg ma promień 10 jednostek (co odpowiada promieniowi tarczy), środkowy okrąg ma promień 5 jednostek, a wewnętrzny okrąg ma promień 1. Oczywiście, wszystkie są wyśrodkowane w tym samym punkcie — to znaczy, okręgi są koncentryczne, ze wspólnym środkiem w punkcie (0, 0).

Napisz funkcję, która dla punktu w celu zdefiniowanego przez jego współrzędne kartezjańskie x i y, gdzie x i y są rzeczywiste, zwraca prawidłową kwotę uzyskaną przez lotkę lądującą w tym punkcie.
W grze zamiast rzutu lotką będziemy losowali 2 liczby całkowite (x, y) określające punkt trafienia lotki. Należy policzyć odległość do środka tarczy i na tej podstawie określić zdobyte punkty.

# data[].attributes.body
Pokaż, że dasz potrafisz. Wyszykuj odpowiednie funkcje, zastosuj je i ciesz się z rozwiązania zadania.

# data[].attributes.attachment_link.description
Nie zmieniaj struktury kodu. Popraw kod tak aby wiświetlał napis “Hello World!

# data[].attributes.attachment_link.readable_text
class Osoba(
    var imie : String, 
    var wiek : Int,
    var zeby : 	Boolean
)


fun main() {
    val o1 = Osoba("Jakub", 17, false)
    val o2 = Osoba("Filip", 17, true)
    val osoby = listOf(o1, o2)
    println("KubuÅ jest starszy: ${o1.wiek > o2.wiek}")
    
    for(i in 0..1){
 
        if(osoby[i].zeby){
            println("${osoby[i].imie} ma zÄby")
        }
        else{
            println("${osoby[i].imie} nie ma zÄbÃ³w")
        }
    }
}

# data[].attributes.body
def selectionSort( itemsList ):
    n = len( itemsList )
    for i in range( n - 1 ):
        minValueIndex = i

        for j in range( i + 1, n ):
            if itemsList[j] < itemsList[minValueIndex] :
                minValueIndex = j

        if minValueIndex != i :
            temp = itemsList[i]
            itemsList[i] = itemsList[minValueIndex]
            itemsList[minValueIndex] = temp

    return itemsList


el = [21,6,9,33,3]

print(selectionSort(el))

# data[].attributes.attachment_link.readable_text
function policz() {
let x = document.getElementById("liczba").value;
let y = document.getElementById("wynik");

if(x>18) {
    y.innerHTML="Masz 18 lat lub wi��cej";
}
else if (x>=12) {
    y.innerHTML="Masz 12 lub wi��cej lat ale mniej ni�� 18";
}
else if (x > 6) {
    y.innerHTML="Masz wi��cej ni�� 6 lat ale mniej ni�� 12";
}
else 


x=y.innerHTML=x;
}

# data[].attributes.attachment_caption
Ten materiał omawia pierwsze kroki do uruchomienia projektu z Django

# data[].attributes.body
Wykonanie po kolei wszystkich poleceń powinno doprowadzić do stworzenia pierwszej aplikacji. Nie zmieniaj nazw zmiennych, wtedy łatwiej dojdziesz do satysfakcjonującego efektu.

# data[].attributes.body
fun main() {

val dzielna = 25

val dzielnik = 7

val reszta dzielna.mod(dzielnik)

println("Reszta z dzielenia $(dzielna)/$(dzielnik) jest $(reszta}")

var zmienna = 20

println("To jest watrość zmiennej: $zmienna 1")

println("A to jest wartość zmiennej powiększona o 2: $[zmienna + 2] 1")

val name = "Ania"

val age = 20

zmienna = 10

zmienna = 8

zmienna zmienna + 3

zmienna += 8

zmienna -= 5

zmienna *= 2

zmienna /= 3

println(zmienna)

var ZmiennaFloat 3.4028235e38f

val zmiennaDouble 1.79769313486231576308

println(Zmiennafloat)

println(ZmiennaDouble)

# data[].attributes.attachment_link.readable_text
1)
fun main() {

    val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    println(listaDoOdczytu)

    

    val listaModyfikowalna = mutableListOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    println(listaModyfikowalna)

}  

2)
fun main() {

    val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    println(listaDoOdczytu.toString())

}  

3)
fun main() {

    val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    println(listaDoOdczytu.toString())

}  
                 
4)
fun main() {
   val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    

   for (i in listaDoOdczytu.indices) {

      println(listaDoOdczytu[i])

   }

}

5)
fun main() {
   val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

   listaDoOdczytu.forEach {println(it)}
}

6)
fun main() {

    val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    

    println("Lista \'listaDoOdczytu\" zawiera " + listaDoOdczytu.size+ " elementÃ³w.")

}

7)
fun main() {

   val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    
   if("cztery" in listaDoOdczytu){

      println(true)

   }else{

      println(false)

   }

}  

8)
fun main() {

   val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")



   if(listaDoOdczytu.contains("Cztery")){

      println(true)

   }else{

      println(false)

   }

  
  
}

9)
fun main() {
  
   val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    
  
   if(listaDoOdczytu.isEmpty()){
  
      println(true)
  
   }else{
  
      println(false)
  
   }
  
}            
                 

# data[].attributes.attachment_link.readable_text
1) fun main() {

    val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    println(listaDoOdczytu)

    

    val listaModyfikowalna = mutableListOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    println(listaModyfikowalna)

}

2) fun main() {

    val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    println(listaDoOdczytu.toString())

} 

3) fun main() {
    val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    

    val itr = listaDoOdczytu.listIterator() 

    while (itr.hasNext()) {

        println(itr.next())

    }

}


4) fun main() {
   val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    

   for (i in listaDoOdczytu.indices) {

      println(listaDoOdczytu[i])

   }

}

5) fun main() {

  val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    

   listaDoOdczytu.forEach { println(it) }

} 

6)  fun main() {

    val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    

    println("Lista \'listaDoOdczytu\" zawiera " + listaDoOdczytu.size+ " elementÃ³w.")

}



7) fun main() {

   val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    
   if("cztery" in listaDoOdczytu){

      println(true)

   }else{

      println(false)

   }

} 



8)  fun main() {

   val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")



   if(listaDoOdczytu.contains("Cztery")){

      println(true)

   }else{

      println(false)

   }

  
  
}


9)fun main() {
  
   val listaDoOdczytu = listOf("jeden", "dwa", "trzy", "cztery", "piÄÄ")

    
  
   if(listaDoOdczytu.isEmpty()){
  
      println(true)
  
   }else{
  
      println(false)
  
   }
  
} 

# data[].attributes.headline
18.09.2024 Vladyslav Shestakov Praca domowa

# data[].attributes.subject
18.09.2024 Vladyslav Shestakov Praca domowa

# data[].attributes.body
index2.php

<?php

$name="Adam";

$pass="hasło";

$x=$_POST["l1"];

$y=$_POST["l2"];

$secret="moje tajne coś";

if($x==$name and $y==$pass)

{

echo $secret;

}

else die("złe dane");

inedx.php

<!Doctype html>

<html ="PL">

<head>

<meta charset="utf-8">

</head>

<body>

<form action="index2.php" method="post">

<input type="text" name="l1"> <br>

<input type="password" name="l2"> <br>

<input type="submit" value="wykonaj">

</form>

</body>

</html>

# data[].attributes.body
Czym jest rekurencja?

Różnica pomiędzy funkcją rekurencyjną a iteracyjną. Napisz funkcję, która rekurencyjnie realizuje dodawanie (mnożenie)

# data[].attributes.body
Pseudo kod :

podprogram NWD(a, b)
    dopóki b ≠ 0
        c := reszta z dzielenia a przez b
        a := b
        b := c
    zwróć a

Przyjmujemy, że wspólny podzielnik liczb a i b jest również podzielnikiem liczby  a mod b.
a mod b oznacza resztę z dzielenia a przez b.
Kod:
<?php
//Algorytm Euklidesa
$a = 11; //przykładowa liczba
$b = 44; //przykładowa liczba

 function NWP($a, $b){
	$x=$a;
	$y=$b;
	while($b!=0){
		$c= $a % $b;
		$a = $b;
		$b = $c;
	}
	return $a;


}
$NWD = NWP($a, $b) ;

echo "Dla a=".$a." i b= ".$b." NWD = ".$NWD;

 echo "<br> Inna wersja, mniej intuicyjna <br>";

$x=$a;
$y=$b;
while($a!=$b){
if($a>$b) $a=$a-$b;
else $b=$b-$a;
}
$NWD = $a;

echo('Dla a='.$x.' i b='.$y.' NWD = '.$NWD);
?>

# data[].attributes.body
Ze strony arkusze.pl pobierz arkusz zadania praktycznego EE.09 z czerwca 2020r. i dokładnie go przeanalizuj. Utwórz na serwerze folder egzamin (W FOLDERZE HTDOCS) a w nim dopiero umieść wszystkie potrzebne pliki i foldery.

# data[].attributes.body
https://docs.google.com/document/d/1c-Trf5QqXk3NnitMBzDBHQOQAlt-bCsm53CbO1GJ6-U/edit?usp=sharing

# data[].attributes.body
Obydwa pliki umieść w tym samym katalogu i przeanalizuj jak dane ze sklepu wędrują do zamówienia.

Zamówienie.php

<?php

define("KOSZULKA", 14.99);

define("SPODNIE", 45.99);

define("CZAPKA", 9.63);

define("P_VAT", 0.22);

$ile_koszulki = $_POST['koszulki'];

$ile_spodnie = $_POST['spodnie'];

$ile_czapki = $_POST['czapki'];

$kwota_koszulki_netto = $ile_koszulki*KOSZULKA;

$kwota_spodnie_netto = $ile_spodnie*SPODNIE;

$kwota_czapki_netto = $ile_czapki*CZAPKA;

$kwota_zamowienia_netto = $kwota_koszulki_netto +

$kwota_spodnie_netto + $kwota_czapki_netto;

$kwota_koszulki_brutto = $kwota_koszulki_netto +

$kwota_koszulki_netto*P_VAT;

$kwota_spodnie_brutto = $kwota_spodnie_netto +

$kwota_spodnie_netto*P_VAT;

$kwota_czapki_brutto = $kwota_czapki_netto +

$kwota_czapki_netto*P_VAT;

$kwota_zamowienia_brutto = $kwota_koszulki_brutto +

$kwota_spodnie_brutto + $kwota_czapki_brutto;

echo "Zamówiłeś za:".$kwota_zamowienia_brutto>" brutto.<br>";

?>

<html>

 <head>

  <meta charset="utf-8">

  <title>Obsługa zamówienia</title>

  <link rel="stylesheet" href="styl.css">

 </head>

 <body>

<?php

echo "<br>Cena netto zamówionych koszulek||" .$kwota_koszulki_netto."<br/>";

echo "Cena netto zamówionych spodni: ..||". $kwota_spodnie_netto."<br/>";

echo "Cena netto zamówionych czapek:..||". $kwota_czapki_netto."<br/>";

echo "Wartość netto całego zamówienia:.||". $kwota_zamowienia_netto."<br/>";

echo "<hr>";

echo "Cena brutto zamówionych koszulek: ".$kwota_koszulki_brutto."<br/>";

echo "Cena brutto zamówionych spodni: ".$kwota_spodnie_brutto."<br/>";

echo "Cena brutto zamówionych czapek: ".$kwota_czapki_brutto."<br/>";

echo "Wartość brutto całego zamówienia: ".$kwota_zamowienia_brutto."<br/>";

 ?>

 </body>

 </html>

# data[].attributes.body
Przeczytaj ten artykuł jeśli masz pytania, czegoś nie rozumiesz to zadaj mi pytanie

# data[].attributes.attachment_link.readable_text
Autor: Codenga 31.07.2023

Bazy danych są kluczowym elementem niemal każdej aplikacji, które wymaga przechowywania danych. W tym artykule omówimy najważniejsze pojęcia związane z bazami danych.
Czym jest baza danych?
Baza danych to zorganizowany zbiór danych, które są przechowywane w taki sposób, aby umożliwić łatwy dostęp, manipulację i zarządzanie nimi.

Wyobraź sobie bazę danych jako gigantyczną, wirtualną skrzynkę, w której możesz przechowywać swoje dane. W skrzynce tej dane są uporządkowane w tabele lub kolekcje z których każda może reprezentować określony rodzaj informacji. Na przykład, dla aplikacji e-commerce możemy mieć tabele z danymi o produktach, klientach, zamówieniach itp.
Zalety korzystania z baz danych

Łatwy dostęp do danych

Trwałe przechowywanie danych, nawet po wyłączeniu aplikacji

Dostęp do danych dla wielu użytkowników jednocześnie

Szybkie wyszukiwanie danych

Spójność danych

Rodzaje baz danych
Istnieje wiele różnych rodzajów baz danych, a wybór odpowiedniego typu zależy od charakteru danych, które aplikacja musi przechowywać oraz od wymagań dotyczących wydajności i skalowalności.
Bazy danych relacyjne (RDBMS)
Relacyjne bazy to jeden z najpopularniejszych typów baz danych. Dane są przechowywane w tabelach, a relacje między tabelami są określane za pomocą kluczy obcych. Przykładami popularnych systemów zarządzania bazami danych relacyjnych ( RDBMS) są:

MySQL

PostgreSQL

Microsoft SQL Server

Oracle Database

SQLite

Bazy danych NoSQL
Bazy danych NoSQL ( Not Only SQL) to zbiór różnorodnych baz danych, które nie korzystają z tradycyjnego modelu tabel i relacji, jak w przypadku baz relacyjnych. Zamiast tego, bazy danych NoSQL często wykorzystują inne struktury danych, takie jak dokumenty, grafy czy kolumny. Przykłady baz typu NoSQL:

MongoDB (baza danych dokumentowa)

Neo4j (baza danych grafowa)

Cassandra (baza danych kolumnowa)

Redis (baza danych typu klucz-wartość)

Bazy danych relacyjne
Popatrzmy teraz na kluczowe pojęcia związane z relacyjnymi bazami danych.
Sposób przechowywania danych
Dane są przechowywane w tabelach, które składają się z wierszy i kolumn. Każda tabela reprezentuje określony rodzaj informacji, na przykład tabela z danymi klientów, tabela z produktami czy tabela z zamówieniami. Kluczowym elementem bazy danych relacyjnej jest możliwość ustanawiania relacji między różnymi tabelami za pomocą kluczy obcych, co pozwala na powiązanie danych z różnych tabel.
Tabela i kolumny
W bazie danych relacyjnej tabela jest zbiorczym kontenerem, który przechowuje dane o tych samych cechach lub typach danych. Każda tabela składa się z kolumn, które określają różne właściwości lub atrybuty danych. Na przykład, tabela z danymi klientów może zawierać kolumny takie jak ID klienta, imię, nazwisko, adres i adres e-mail.
Klucz główny i klucz obcy
W każdej tabeli można zdefiniować klucz główny (primary key), który jednoznacznie identyfikuje każdy wiersz w tabeli. Klucz główny musi być unikalny w obrębie tabeli. Dzięki temu możemy łatwo odnajdywać i aktualizować konkretny rekord.

Klucz obcy (foreign key) to pole w tabeli, które jest powiązane z kluczem głównym w innej tabeli. Pozwala to na ustanowienie relacji między tabelami. Na przykład, w tabeli z zamówieniami możemy użyć klucza obcego, aby wskazać na klienta z tabeli klientów, który złożył to zamówienie.
Zalety relacyjnych baz danych

Struktura i spójność: bazy danych relacyjne oferują ściśle określoną strukturę, co pomaga utrzymać spójność danych i uniknąć duplikacji.

Dostęp do danych: język SQL zapewnia łatwy dostęp do danych oraz możliwość filtrowania, sortowania i grupowania wyników zapytań.

Zarządzanie danymi: relacyjne bazy oferują zaawansowane funkcje zarządzania danymi, takie jak indeksy, transakcje i ograniczenia, co pomaga w zachowaniu integralności danych.

Język zapytań SQL
A skoro już pojawił się temat języka SQL, to na pewno warto wspomnieć o nim kilka słów. To standardowy język do zarządzania relacyjnymi bazami danych. Za jego pomocą możemy wyciągać dane z bazy, wprowadzać nowe dane, modyfikować dane oraz wykonywać różne operacje administracyjne.
Operacje w SQL
W języku SQL można wykonywać różne operacje związane z danymi. Popatrzmy na prosty przykład:

 SELECT name, address FROM customers WHERE age > 18;

Ten fragment kodu to tzw. zapytanie SQL. Za jego pomocą odczytujemy zawartość tabeli o nazwie customers. Wyciągamy dane z kolumn name oraz address. Na końcu zapytania mamy warunek: interesują nas osoby, które w kolumnie age (wiek) mają wartość większą niż 18.

Tego przykładu użyliśmy po to, aby zilustrować ideę pisania zapytań do bazy za pomocą języka SQL.
Bazy danych NoSQL
Bazy danych NoSQL (Not Only SQL) różnią się od tradycyjnych baz relacyjnych w sposób fundamentalny. W przeciwieństwie do baz relacyjnych, bazy danych NoSQL nie korzystają z modelu tabel i relacji. Zamiast tego, wykorzystują różnorodne struktury danych, które są odpowiednio dostosowane do różnych rodzajów danych i zastosowań. Bazy danych NoSQL stały się popularne ze względu na swoją elastyczność, skalowalność i zdolność do obsługi dużych ilości danych w czasie rzeczywistym.
Przykładowe sposoby przechowywania danych w bazie NoSQL Bazy danych dokumentowe
Bazy danych dokumentowe przechowują dane w formie dokumentów, które mogą być w formacie JSON, BSON, XML lub innym. Każdy dokument zawiera zestaw kluczy i wartości, które reprezentują właściwości obiektu. Dokumenty te mogą być różnorodne, co daje dużą elastyczność w modelowaniu danych. Przykładami baz danych dokumentowych są: MongoDB, Couchbase.
Bazy danych kolumnowe
Bazy danych kolumnowe przechowują dane w kolumnach, a nie jak tradycyjne bazy danych relacyjne w formie wierszy. Jest to szczególnie efektywne, gdy aplikacja musi przetwarzać duże ilości danych w jednym zapytaniu, a potrzebuje tylko pewnych kolumn. Przykładami baz danych kolumnowych są: Apache Cassandra i HBase.
Bazy danych grafowe
Bazy danych grafowe są zaprojektowane do przechowywania danych w formie grafów, które składają się z wierzchołków (węzłów) i krawędzi (relacji) między nimi. Są one idealne do modelowania i rozwiązywania problemów związanych z sieciami i powiązaniami między danymi. Przykładami baz danych grafowych są: Neo4j, Amazon Neptune.
Bazy danych typu klucz-wartość
Bazy danych typu klucz-wartość przechowują dane jako prosty zestaw par klucz-wartość. Są one wyjątkowo szybkie i skalowalne, co sprawia, że są popularne w aplikacjach wymagających szybkiego dostępu do danych. Przykładami baz danych typu klucz-wartość są: Redis, Riak.
Plusy i minusy baz typu NoSQL
Bazy tego typu czasami wzbudzają pewne kontrowersje. Doskonale się sprawdzą w pewnych sytuacjach, ale często lepszym wyborem jest użycie baz relacyjnej. Wszystko oczywiście zależy od wymagań danego projektu.

Bazy danych NoSQL oferują dużą elastyczność w modelowaniu danych, ponieważ nie wymagają ściśle określonego schematu, jak ma to miejsce w bazach relacyjnych. Można łatwo dodawać i modyfikować dane, co ułatwia rozwijanie aplikacji i wprowadzanie zmian w strukturze danych.

Bazy danych NoSQL, takie jak bazy typu klucz-wartość czy kolumnowe, są bardzo wydajne w wykonywaniu prostych zapytań na dużych ilościach danych. Dzięki swojej specyficznej strukturze przechowywania, pozwalają na szybkie wyszukiwanie i dostęp do danych, co jest szczególnie ważne w aplikacjach o dużej liczbie użytkowników.

NoSQL doskonale nadaje się do przechowywania danych nierelacyjnych, takich jak dokumenty, grafy czy dane czasoszeregowe. W takich przypadkach, gdzie struktura danych może być złożona i zmienna, bazy NoSQL oferują bardziej naturalne podejście do zarządzania danymi niż tradycyjne bazy relacyjne.

Brak powszechnych standardów wśród baz danych NoSQL może sprawiać, że wybór odpowiedniego rozwiązania może być trudny. Istnieje wiele różnych typów baz NoSQL, z różnymi strukturami danych i cechami, co może prowadzić do problemów związanych z jednolitością i integracją danych.

W porównaniu z tradycyjnymi bazami danych relacyjnymi, społeczność wokół baz NoSQL jest zazwyczaj mniejsza, a dostępność narzędzi i wsparcia może być ograniczona. To może wpłynąć na trudności w rozwiązywaniu problemów i zdobywaniu wiedzy na temat konkretnych baz danych.

Niektóre bazy danych NoSQL nie oferują pełnej transakcyjności, która jest znana z baz relacyjnych. Oznacza to, że w przypadku awarii lub problemów z połączeniem, może wystąpić utrata danych lub niepełne operacje. W niektórych przypadkach, w których wymagana jest ścisła spójność danych, brak transakcyjności może stanowić problem.
Podstawy modelowania danych
Modelowanie danych to proces planowania struktury bazy. W procesie tym chodzi o to, aby optymalnie zaplanować strukturę danych, relacje między danymi oraz wybrać odpowiednie typy pól. Ostatecznym celem jest zbudowanie takiej struktury bazy, która umożliwia efektywne i spójne przechowywanie informacji.
Podsumowanie i kolejne kroki
Teraz już wiesz, jakie są kluczowe cechy baz relacyjnych oraz baz typu NoSQL. Chcesz nauczyć się od podstaw pracy z danymi oraz bazami relacyjnymi? Skorzystaj ze ścieżki kariery SQL Developer. Ścieżka kariery sprawi, że staniesz się wartościowym specjalistą od SQL. Zawiera ona dziesiątki zadań oraz ćwiczeń, dzięki którym zdobędziesz przydatne na rynku pracy umiejętności.

# data[].attributes.attachment_link.description
Bazy danych są kluczowym elementem niemal każdej aplikacji, które wymaga przechowywania danych.

# data[].attributes.body
trzeci z 3 plików

# data[].attributes.body
drugi z 3 plików

# data[].attributes.body
Jeden z 3 plików

# data[].attributes.body
Skrypt php przetwarzający dane z formularza.

# data[].attributes.body
Plik html z formularzem

# data[].attributes.body
Dokumentacja PHP

PHP - definicja  Wszystko, co musicie wiedzieć o PHP. Jakie ma zalety, jakie wady? - Just Geek IT (justjoin.it)

Zaczynamy naukę programowania w PHP.

# data[].attributes.attachment_link.description
The PHP Manual is available online in a selection of languages. Please pick a language from the list below.

# data[].attributes.body
Zdarzenia w JavaScript to pewne akcje, które są podejmowane w przeglądarce, w wyniku zaistnienia danej sytuacji, na przykład naciśnięcia klawisza na klawiaturze, myszce, najechanie kursorem na dany element strony, załadowanie strony internetowej itp. W języku JavaScript istnieje gotowy zestaw predefiniowanych zdarzeń. Jest ich dość dużo, a tylko wybrane są częściej używane. Tutaj poznasz kilka rodzajów predefiniowanych zdarzeń i dowiesz się jak je wykorzystywać.

Zdarzenia w JavaScript - Medianauka.pl

# data[].attributes.attachment_link.readable_text
Zdarzenia w JavaScript to pewne akcje, które są podejmowane w przeglądarce, w wyniku zaistnienia danej sytuacji, na przykład naciśnięcia klawisza na klawiaturze, myszce, najechanie kursorem na dany element strony, załadowanie strony internetowej itp. W języku JavaScript istnieje gotowy zestaw predefiniowanych zdarzeń. Jest ich dość dużo, a tylko wybrane są częściej używane. W niniejszym artykule zapoznaj się z rodzajami predefiniowanych zdarzeń, w następnym kroku dowiesz sie jak je wykorzystywać.

Spis treści

W poniższych tablicach wymieniono zdarzenia z podziałem na kategorie. Czcionką pogrubioną zaznaczono te, które są częściej wykorzystywane.

Zdarzenia związane z obsługą myszy

Obiekty związane ze zdarzeniami MouseEvent

W związku z zajściem zdarzenia związanego z obsługą myszy możemy odczytywać pewne właściwości, które zostały zestawione w poniższej tablicy. Odczyt tych parametrów odbywa się poprzez obiekt event.

Zdarzenia związane z obsługą klawiatury

Obiekty związane ze zdarzeniami KeyboardEvent

W związku z zajściem zdarzenia związanego z obsługą klawiatury możemy odczytywać pewne właściwości, które zostały zestawione w poniższej tablicy. Odczyt tych parametrów odbywa się poprzez obiekt event.

Zdarzenia związane z obiektami i oknami

Obiekty związane ze zdarzeniem HashChangeEvent

Zdarzenia związane z formularzami

To zdarzenie zachodzi, gdy użytkownik wpisał coś w pole formularza input typu search.

Zdarzenie to zachodzi po tym jak użytkownik zaznaczył jakiś tekst w polu input lub textarea.

Zdarzenia związane z przeciąganiem obiektów

Zdarzenia związane z edycją

Zdarzenia związane z wydrukiem

Zdarzenia związane z multimediami

Zdarzenia związane z animacją

Zdarzenia związane z serwerem

Zdarzenia różne

Zdarzenia dotykowe

Inne zagadnienia z tej lekcji

© medianauka.pl, 2016-11-20, A-3295

# data[].attributes.attachment_link.description
Zdarzenia w JavaScript to pewne akcje, które są podejmowane w przeglądarce, w wyniku zaistnienia danej sytuacji, na przykład naciśnięcia klawisza na klawiaturze, myszce, najechanie kursorem na dany element strony, załadowanie strony internetowej.

# data[].attributes.body
Tworzenie aplikacji typu galeria obrazów - dodanie formularza kontaktowego

Link do przykładowego rozwiązania http://ckz.net.pl/galeria/galeria.php

Dodawanie CSS na stronę

Styl zapisany w języku CSS możemy dodać do strony na kilka sposobów.

Style możemy dodawać bezpośrednio do elementu używając atrybutu style="".

CSS możemy również zamieścić w specjalnie do tego przeznaczonym elemencie html <style>.

Trzecim sposobem jest utworzenie oddzielnego pliku, w którym będziemy przetrzymywać wszystkie nasze reguły CSS.

Sposoby dodawania CSS:

atrybut style=""

<p style="">treść akapitu</p>
<p style="background-color: yellow;">Żółte Tło</p>

elementy <style>

w zasadzie w całym dokumencie html, zarówno w sekcji <body> jak i <head>, z jednym warunkiem, zawsze powyżej elementu, którego formatowanie dotyczy<body>
  <style>
    p {font: 16px Arial;}
   </style>
  <p>Paragraf</p>
</body>

zewnętrzny plik CSS  - służy do tego znacznik link

Element <link> umieszczamy zawsze w sekcji <head>

<head>
    <link rel="stylesheet" href="css/main.css">
</head>

właściwość href wskazuje na względny adres pliku .css

# data[].attributes.attachment_link.title
Lekcja 12: CSS podstawy - Kurs CSS / HTML

# data[].attributes.attachment_link.description
Kurs CSS. Podstawy CSS, nauka CSS3 za darmo. Podstawy HTML. Wejdź i dowiedz się co to jest język CSS, czym się różni od HTML?

# data[].attributes.body
W  pliku  index.css zapisz taka treść.

html{
background-color: rgba(89, 131, 252, 1);
background-image: linear-gradient(70deg, rgba(89, 181, 252, 1) 15%, rgba(141, 53, 86, 1) 90%);
}
li{
border:1px blue solid;
margin-left:10%;
width:30%;
background-color:rgba(222, 123,132,0.2);
}
body{
padding:5%;
background-color:lightgray;
}
img{
display: block;
margin-left: auto;
margin-right: auto;
}

div.galeria{
margin: 5px;
border: 1px solid #ccc;
float: left;
width: 180px;
}

div.galeria:hover {
border: 1px solid #777;
}

div.galeria img {
width: 100%;
height: auto;
}

div.desc {
padding: 15px;
text-align: center;
}
#clear {
clear:both;
}
#h1{
background-color:azure;
color:orange;
}
#h2{
background-color:blue;
color:yellow;
}
#h3{
background-color:magenta;
color:green;
}
#h4{
background-color:rgb(255, 100, 0);
color:rgb(0,155,250);
}
#h5{
background-color:violet;
color:lightgreen;
}
#h6{
background-color:red;
color:cyan;
}
#p{
background-color:yellow;
color:blue;
}

Zamiast odrębnego pliku można też opis CSSa umieścić na dole sekcji head pomiędzy znacznikami <style> i <style>

# data[].attributes.body
Spodziewam się, ze już potrafisz:

1. utworzyć podstawowy szablon strony HTML5
2. Wstawić jakąś treść na stronę
3. Zastosować reguły CSS {przynajmniej podstawowe elementy)

Chciałbym móc po każdej lekcji coś tutaj dopisać!

# data[].attributes.body
Twoim zadaniem jest utworzenie strony HTML z galerią ze zdjęciami. W tym celu wyszukaj w internecie kilku (4 do 10) zdjęć o tematyce, która cię interesuje i wklej je do swojej strony. Możesz też zapisać te obrazki w katalogu domowym twojej strony i w galerii zamiast adresu UL podać nazwy tych plików.