Warum ist Schach derzeit kein sehr gutes Spiel?
Schach ist eines der mächtigsten intellektuellen Spiele, die der Menschheit seit mehr als 1500 Jahren bekannt sind. Und all die Jahre war Schach in einer sehr starken Position. Aber seit 30 Jahren ist Schach nicht mehr so gut für intellektuelle Kämpfe, aber warum? Ich denke, dass diese Situation mit der Entwicklung der Informatik korreliert. Computer und Algorithmen werden so schnell und effizient, dass Schach gehackt werden kann. Deshalb spielen die Leute nicht mehr so gerne Schach wie früher. Der Computer kann jederzeit im Spiel helfen. Das Schlimmste ist, dass der Computer einen Menschen im Denken befreit. Hier kann man sich streiten. Allerdings, der Computer kann jedoch gute Ergebnisse erzielen. Zu wissen, dass der Computer effizient ist, verdirbt den Spaß am Spiel. Der Computer nicht zu benutzen, macht einen Menschen nicht frei. Denn auf diese Weise betrügt sich der Mensch und erlaubt sich nicht, die volle Kraft dessen zu nutzen, was überhaupt existiert. Ich denke, dass professionelle Schachspieler in der aktuellen Situation die volle Leistungsfähigkeit von Computerberatungssystemen ohne Einschränkungen nutzen sollten. So wird die Situation fair. Aber es verdirbt auch den Spaß am Spiel.
Wyuczona bezradność
Co to jest? Czy dorośli mogą świadomie zrezygnować ze swoich możliwości z tego powodu, że tak im będzie lepiej w życiu? Tutaj trzeba koniecznie ustalić dokładnie, jakie są te oczekiwania. Co to w ogóle oznacza "lepiej w życiu"? Czy może na przykład hikikomori to właściwie typowa wyuczona bezradność? Niestety, jak to odbywa się retoryczne w dyskursie, nie można stanowczo odpowiadać na te pytania. Bo to są pytania jak najbardziej filozoficzne. Odpowiedz na te pytania całkowicie zależy od tego, kto pyta, kto jest świadkiem procesu komunikatywnego. Hikikomori ("wycofany") jako ofiara tego procesu może nie dawać sobie sprawy co się dzieje; jak świat toczy się wokół niego. A może to przykład optymalizacji życia społecznego, kiedy członkowie społeczności podświadomie rezygnują z socjalnej aktywności, w celu oszczędzania energii społecznej czy psychicznej? Mam na myśli optymalizację bardziej w stylu psychofizycznym, kiedy energia takiego rodzaju zostaje uwolniona dla przetrwania jakiegoś kryzysu. Na przykład kryzysu przeludnienia.
Fancy Sequence
/*
#-------------------------------------------------------------#
# #
# version 0.0.2 #
# https://leetcode.com/problems/fancy-sequence/ #
# #
# Aleksiej Ostrowski, 2021 #
# #
# https://aleksiej.com #
# #
#-------------------------------------------------------------#
*/
package main
import (
"fmt"
"os"
)
const crt = 84467440737095516 // max(uint64) = 8446744073709551615
const md = 1000000007
type Oper struct {
o int8
v int8
h int32
}
type Fancy struct {
arr []int8
opr []Oper
cas map[int]int
}
func Constructor() Fancy {
return Fancy{}
}
func (this *Fancy) Append(val int) {
this.arr = append(this.arr, int8(val))
}
func printList(l Fancy) {
for _, v := range l.arr {
fmt.Print(v, " ")
}
fmt.Println()
}
func (this *Fancy) AddAll(inc int) {
this.opr = append(this.opr, Oper{-2, int8(inc), int32(len(this.arr))})
this.cas = make(map[int]int)
/*
for k := range this.cas {
delete(this.cas, k)
}
*/
}
func (this *Fancy) MultAll(m int) {
this.opr = append(this.opr, Oper{-1, int8(m), int32(len(this.arr))})
this.cas = make(map[int]int)
/*
for k := range this.cas {
delete(this.cas, k)
}
*/
}
func (this *Fancy) GetIndex(idx int) int {
if idx < 0 || idx >= len(this.arr) {
return -1
}
if val, ok := this.cas[idx]; ok {
return val
}
var vv uint64
vv = uint64(this.arr[idx])
for _, v := range this.opr {
if idx >= int(v.h) {
continue
}
switch os := v.o; os {
case -2:
vv += uint64(v.v)
case -1:
vv *= uint64(v.v)
}
if vv > crt {
vv = vv % md
}
}
if vv > md {
vv = vv % md
}
if this.cas == nil {
this.cas = make(map[int]int)
}
this.cas[idx] = int(vv)
return int(vv)
}
func main () {
obj := Constructor()
obj.Append(2)
obj.Append(4)
obj.Append(1)
obj.Append(6)
printList(obj)
obj.AddAll(9)
obj.AddAll(1)
obj.MultAll(2)
fmt.Println(obj.GetIndex(0))
os.Exit(1)
obj.MultAll(9)
obj.AddAll(2)
fmt.Println(obj.GetIndex(3))
obj.Append(7)
obj.Append(5)
obj.Append(3)
obj.AddAll(4)
obj.MultAll(5)
obj.AddAll(4)
fmt.Println(obj.GetIndex(1))
}
Median of Two Sorted Arrays
/*
#-------------------------------------------------------------#
# #
# version 0.0.1 #
# https://leetcode.com/problems/median-of-two-sorted-arrays/ #
# #
# Aleksiej Ostrowski, 2020 #
# #
# https://aleksiej.com #
# #
#-------------------------------------------------------------#
*/
package main
import (
"fmt"
)
func findMedianSortedArrays(nums1 []int, nums2 []int) float64 {
i1 := 0
i2 := 0
var x1 []int
var x2 []int
x1 = nums1
x2 = nums2
switch {
case (len(nums1) == 0) && (len(nums2) > 0):
x1 = nums2
x2 = nums1
case (len(nums1) > 0) && (len(nums2) > 0):
if nums1[i1] > nums2[i2] {
x1 = nums2
x2 = nums1
}
}
r := make([]int, len(x1) + len(x2))
ir := 0
for {
if i1 >= len(x1) {
break
}
e1 := x1[i1]
r[ir] = e1
ir += 1
e3 := e1
flag := true
if i1 + 1 < len(x1) {
e3 = x1[i1 + 1]
flag = false
}
for {
if i2 >= len(x2) {
break
}
e2 := x2[i2]
if (e2 >= e1) && ( (e2 <= e3) || flag) {
r[ir] = e2
ir += 1
i2 += 1
} else {
break;
}
}
i1 += 1
}
ifz := len(r) % 2 == 0
fmt.Println(r)
ind := len(r) / 2
fmt.Println("ind = ", ind, "el = ", r[ind])
if ifz {
return (float64(r[ind - 1]) + float64(r[ind])) * 0.5
} else {
return float64(r[ind])
}
}
func main() {
a := []int{1,34,56,100,200, 201, 500}
b := []int{250}
// a := []int{1,2,3,4,5}
// b := []int{}
fmt.Println("a = ", a)
fmt.Println("b = ", b)
fmt.Println(findMedianSortedArrays(a, b))
}
Two Sum
#-----------------------------------------#
# #
# version 0.0.1 #
# https://leetcode.com/problems/two-sum/ #
# #
# Aleksiej Ostrowski, 2020 #
# #
# https://aleksiej.com #
# #
#-----------------------------------------#
from itertools import combinations
class Solution(object):
def __init__(self, nums, target):
self.nums = nums
self.target = target
def twoSum(self):
"""
:type nums: List[int]
:type target: int
:rtype: List[int]
"""
new_nums = sorted(list(enumerate(self.nums)), key = lambda x: x[1])
for x in combinations(range(len(new_nums)), 2):
if new_nums[x[0]][1] + new_nums[x[1]][1] == self.target:
return list((new_nums[x[0]][0], new_nums[x[1]][0]))
'''
nums = [0,4,3,0]
target = 0
nums = [2, 20, 100, 7, 11, 15]
target = 9
'''
nums = [-3,4,3,90]
target = 0
print(nums)
print(target)
sol = Solution(nums, target)
print(sol.twoSum())