Einfach "ffmpeg" installieren und ...
ffmpeg -i video.mp4 frame%06d.png
... in der Konsole eingeben. Fertig! :)
Ansonsten geht das mit dem VLC-Player, falls dir eine GUI lieber ist. Was du da genau machen musst verrät dir die erstbeste Googlesuche.
Ich würde an deiner Stelle Java nehmen, allein schon, weil du dich damit ja schon ein wenig eingefummelt hast.
Allerdings ist C++ und Python in vielerlei Hinsicht völlig anders, und diese beiden Sprachen unterscheiden sich teilweise drastisch von Java.
Deshalb würde ich dir langfristig zu Java und Python und C++ raten. Wenn du mal ein paar Wochen oder Monate in all diese Sprachen hinein geschnuppert hast, kannst du dich ja immer noch spezialisieren.
Trotzdem solltest du erst mal Java halbwegs "fertig" machen, weil du sonst gerade als Einsteiger evtl. durcheinander kommst. :)
Fazit: Kurzfristig erst mal Java, langfristig alles was du kriegen kannst. ;)
Wenn es wirklich überall laufen und portabel sein soll, dann so:
#!/bin/sh
sum="0"
i=0
while read num; do
test $num -eq 0 && break
sum="$sum + $num"
i=`expr $i + 1`
done
sum=`expr \( $sum \) \* 1000 / $i`
echo "$sum * 10^-3"
Die Ein- und Ausgabe sieht dann so aus:
1
2
3
2
1
0
1800 * 10^-3
Ansonsten kannst du auch die andere Lösung von andie00 nehmen. :)
Mit Streams und Lambdas ... oder rekursiv. :)
Sofern überhaupt ein catch-Block und dazu noch ein Passender nach dem try vorhanden ist, geht es dann dort direkt nach dem Werfen der Ausnahme weiter.
D. h., wenn beim zweiten println() eine Ausnahme geworfen wird, dann wird das dritte println() NICHT ausgeführt werden, sondern stattdessen der Code im catch-Block ... wie gesagt - falls überhaupt vorhanden. :)
Ich war gestern in einem Yakiniku-Laden und habe Steak im Stück mit Stäbchen gegrillt und verspeist. Suppen isst man hier sowieso mit Stäbchen. :)
Wir haben ein Auto für die Stadt gesucht, mit möglichst geringem Spritverbrauch.
Die Japanischen Autos (gleich mehrere, von verschiedenen Herstellern) verbrauchen VIEL weniger, als deutsche Modelle.
Knapp 1,5 Liter auf 100 km ... An der Tankstelle war ich schon seit 3 Monaten nicht mehr. :)
Ich denke, das hat schon etwas mit "Qualität" zu tun.
Da gibt es unglaublich viele Möglichkeiten, die - je nachdem wie stark deine Uni blockt - mehr oder weniger leicht umzusetzen sind.
Für den Anfang könntest du TOR probieren, oder wenn dir die Bandbreite dabei nicht reicht, dir irgendwo einen VPN-Zugang besorgen.
Falls auch das nicht funktioniert, kannst du dir einen SOCKS-Proxy über einen reversen sshtunnel basteln. Damit kommt man um weit mehr als 95% aller Netzsperren rum, du brauchst dafür aber einen externen Server.
Falls auch das alles nicht funktioniert, kannst du dir eine eigene Lösung basteln, was aber etwas mehr Aufwand bedeutet, und für Laien vermutlich unmöglich umzusetzen ist.
Hab als Kind mal neben einer Weide mit Rindern ins Gras gepinkelt und dabei den Elektrozaun übersehen. :)
Blender: Google mal nach "blender rigid body tutorial". :)
Das geht sehr eingeschränkt mit Membervariablen eines Objekts und ganz ekelhaften Hacks der Reflection-API, aber vermutlich willst du einfach nur eine Map nutzen:
Map<String, Integer> map = new HashMap<>();
for (int i = 0; i < 3; ++i) {
map.put("var" + i, i);
}
System.out.println(map.get("var1"));
Oder du greifst einfach auf ein/e Array/ArrayList mit Index zu, wie die anderen schon geschrieben haben. :)
Außerdem gibt es noch die Möglichkeit den Bytecode in der aktuell laufenden JVM zu manipulieren, aber das ist recht kompliziert und würde dich bei weitem überfordern. (Profiler und andere Lowlevel-Dinge tun das ... nichts für Einsteiger!)
Hier gibt es unzählige Links zu dem Thema:
https://www.reddit.com/r/java/comments/6luknd/where_can_i_find_programming_exercises_to_help/
So, ich hab den Code jetzt mal getestet, und in meiner vorherigen Antwort waren natürlich ein paar Fehler drin. (Ist schon spät!) :)
Speichere folgenden Quelltext in "asmfunc.asm":
global xor_mem
section .text
xor_mem:
mov ecx, [esp + 8]
mov eax, [esp + 4]
mov edx, eax
add edx, ecx
.loop:
cmp eax, edx
je .done
xor [eax], byte 0xFE
inc eax
jmp .loop
.done:
ret
Das hier speicherst du in "asmfunc.h":
#pragma once
#ifndef GUARD_ASMFUNC_H
#define GUARD_ASMFUNC_H
#include <stdlib.h> /* size_t */
#ifdef __cplusplus
extern "C" {
#endif
void xor_mem(
void * const buf,
const size_t len
);
#ifdef __cplusplus
}
#endif
#endif
Das hier ist das Testprogramm "main.c":
#include <stdio.h> /* printf, puts */
#include <stdlib.h> /* EXIT_SUCCESS, size_t */
#include <string.h> /* strlen */
#include "asmfunc.h"
void dump(
const char * const msg,
const char * const buf,
const size_t len
) {
size_t c = '\0';
size_t i = 0;
size_t j = 0;
printf("%s: '%s'", msg, buf);
for (i = 0; i < len; ++i) {
printf("%s", i ? ", " : " => ");
c = ((size_t)buf[i]) & 0xFF;
j = 8;
while (j) {
printf("%c", !!(c & (1 << --j)) + '0');
}
}
puts("");
}
int main(void) {
char cstr[] = "foobar";
const size_t len = strlen(cstr);
dump("A", cstr, len);
xor_mem(cstr + 2, 3);
dump("B", cstr, len);
xor_mem(cstr + 2, 3);
dump("C", cstr, len);
return EXIT_SUCCESS;
}
Und zum bauen speicherst du eine "makefile":
prog != basename `pwd`
prog := $(prog).elf
srcs != find . -type f -name '*.c'
hdrs != find . -type f -name '*.h'
asms != find . -type f -name '*.asm'
cos := $(srcs:%.c=%.c.o)
aos := $(asms:%.asm=%.asm.o)
cc := gcc
cc_flags := \
-std=c89 -O0 -g -m32 \
-pedantic -Wall -Wextra -Wpedantic \
-Werror
.PHONY : all clean
all : clean $(prog)
time -p ./$(prog)
clean :
rm -vf *~ $(prog) *.o
$(prog) : $(cos) $(aos)
$(cc) $(cc_flags) -o $@ $^
%.c.o : %.c $(hdrs) makefile
$(cc) $(cc_flags) -o $@ -c $<
%.asm.o : %.asm makefile
nasm -f elf -o $@ $<
Wenn du diese 4 Dateien in einem leeren Verzeichnis gespeichert hast, tippst du einfach ...
make
... ein, und solltest - wenn alles glatt geht - neben vielen Ausgaben von make selbst, am Ende diese Ausgabe erhalten:
A: 'foobar' => 01100110, 01101111, 01101111, 01100010, 01100001, 01110010
B: 'fo???r' => 01100110, 01101111, 10010001, 10011100, 10011111, 01110010
C: 'foobar' => 01100110, 01101111, 01101111, 01100010, 01100001, 01110010
(Die Nicht-ASCII-Zeichen aus Zeile B habe ich mal durch Fragezeichen ersetzt, weil GF sonst meckert!)
Also wie du siehst, funktioniert die xor_mem() Funktion in Assembler einwandfrei, nachdem ich ein paar Schönheitsfehler korrigiert habe.
In dem Verzeichnis sollten jetzt zwei Objektdateien (mit Endung *.o) und eine ausführbare ELF-Datei (mit Endung *.elf) liegen.
Ich hab das mit gmake, gcc, yasm und nasm ausprobiert, und scheint alles zu funktionieren. Kannst ja mal selber mit rumspielen. :)
Vorweg: Ich habe gerade noch etwas anderes zu tun und leider keine Zeit, den folgenden Code zu testen!
Aber ich hoffe, dass ich jetzt keinen Flüchtigkeitsfehler eingebaut habe. Zum besseren Verständnis, habe ich einzelnen Bereichen die Repräsentation in C als Kommentar hinzugefügt:
; void xor_mem(
; void * const buf,
; const unsigned long len
; );
xor_mem:
; ecx = len;
mov ecx, DWORD PTR [esp + 0x8] ; len
; if (0 == len) goto done;
test ecx, ecx
je .done
; eax = buf;
mov eax, DWORD PTR [esp + 0x4]
; edx = buf + len;
mov edx, eax
add edx, ecx
.loop:
; *buf ^= 0xFE;
xor BYTE PTR [eax], 0xFE
; ++buf;
inc eax
; if (eax != edx) goto loop;
cmp eax, edx
jne .loop
.done:
; return;
ret
Dazu einige Anmerkungen:
Aber wie gesagt ... der obige Code ist NICHT getestet! Falls ich einen Bug eingebaut haben sollte, sorry. :)
PS: Du machst noch einige typische Einsteigerfehler, aber das ist bei jedem so! Assembler ist eben kein Pippifax wie VB.net oder so. Es dauert eine ganze Weile, bis man sich durchgewurschtelt hat, also nicht aufgeben, und immer schön weiter probieren, auch wenn du die merkwürdigsten Heisenbugs fabrizierst, und es einfach nie zu klappen scheint. Viel Erfolg! ;)
Alle von dir genannten und sogar noch weit mehr.
Aber was bringen dich unsere Antworten jetzt weiter? :)
Da du bei Kali viel auf der Kommandozeile rumfummeln wirst, lohnt es sich, die Programmierung mit der Shell (Bash) zu lernen.
Gerade häufig wiederkehrende Aufgaben kannst du damit komfortabel automatisieren, und in Dateien für später abspeichern, sodass du nicht immer die selben Dinge erneut eintippen musst.
Zur Shellprogrammierung an sich gehört natürlich auch der Umgang mit den Standardwerkzeugen, wie grep, sed, awk, cut, paste, tr, iconv, find, und sehr vielen weiteren.
Gerade da es dir ja um Kali geht, kommst du mit Kenntnissen der Bash und den Standardtools am weitesten, gerade wenn du Software einsetzen willst, die im Terminal und nicht mit GUI läuft.
Allerdings ist Python auch sehr gut und mächtig, wenn du dir kleine Werkzeuge zusammen bauen willst, oder Software fremd steuern willst, die eine Python-Schnittstelle anbieten.
Ob du nun die Bash, Python oder eine andere Sprache bevorzugst, bleibt dir überlassen. Aber ich würde sagen, dass Shellkenntnisse bei einem Linuxsystem wie Kali noch viel wichtiger sind, als es bei Python der Fall ist.
Idealerweise solltest du beides halbwegs nutzen können, aber für den Anfang rate ich dir zur Shell mit irgend einem akzeptablen Tutorial, welches du sicher über Google finden wirst. :)
Deutschland hat pro Kopf knapp den anderthalbfachen CO2 Ausstoß der Japaner.
Deutschland ist stolz auf seine Recycling-Infrastruktur, obwohl nur knapp 12% des Kunststoffmülls wirklich recycled werden. Der Rest wurde bisher immer verbrannt oder nach China "exportiert".
Werden CO2 Werte in Deutschland deshalb verharmlost?
PS: Deine Frage könnte man auf so ziemlich jedes Industrieland der Welt übertragen. :)
Als Kind habe ich über einen recht langen Zeitraum hin und wieder sehr klar Dinge gesehen und auch mit diesen interagiert.
Damals konnte ich mir das mit drei bis fünf Jahren nicht erklären, bin inzwischen aber davon überzeugt, dass es wohl mit dem Entwicklungsprozess des Gehirns zu tun hatte.
Das zweite und letzte mal hatte ich so etwas, als ich einen speziellen französischen Schimmelkäse probiert hatte, und der mir so gut geschmeckt hatte, dass ich gar nicht aufhören konnte, und das ganze Ding alleine aufgegessen habe. Dazu muss ich sagen, dass diese Sorte Schimmel in Deutschland verboten ist und man sie nur direkt in Frankreich bekommt.
Inzwischen weiß ich auch warum das so ist, und warum ich nie wieder alleine einen ganzen Käse essen werde. Mir war in dem Moment aber klar, dass ich halluziniere, und nichts von dem real ist, was ich sehe.
Eine extrem interessante Erfahrung aber war, dass ich die Halluzination verschwommen wahrgenommen habe, als ich meine Brille absetzte, und sie wieder scharf wurden, sobald ich meine Brille wieder aufgesetzt habe. Das habe ich zwei bis drei mal wiederholt, mit dem selben Effekt, und ich erinnere mich noch genau, dass ich dachte: "Man, können Halluzinationen real sein".
In beiden Fällen, also weder die Erfahrung als Kind, noch der französische Schimmelkäse, haben mich diese Erlebnisse von der Existenz von Geistern überzeugt. Im Gegenteil: Ich weiß dadurch, zu was das Gehirn im Stande ist und glaube erst mal grundsätzlich gar nichts, ohne es irgendwie empirisch belegen zu können ... das gilt auch für Dinge, die ich selbst mit meinen eigenen Augen sehe.
Außerdem kann ich Leute nicht verstehen, die Drogen nehmen. Ich trinke nicht mal Alkohol, aber der Unfall mit dem französischen Käse hat voll rein gehauen ... wie man sich so etwas freiwillig mithilfe von Drogen antun kann, bzw. was daran jetzt so schön sein soll, erschließt sich mir nicht.
Fazit: Angst vor Geistern habe ich überhaupt nicht, da sie nicht existieren, aber bei Schimmelkäse bin ich jetzt vorsichtiger. ;)
Wie kann ich das schnell beheben, ohne mich jetzt komplett mit Rechten auseinanderzusetzen?
Im Gegensatz zu den gängigen BSDs haben Jails unter Linux nur eine sehr untergeordnete Rolle, was man auch daran sieht, dass man kinderleicht aus diesen ausbrechen kann.
Es sind nur eine Hand voll ASCII-Zeichen auf der Kommandozeile nötig, um aus so einem Jail auszubrechen. (Das gilt, wie gesagt, nur für Linux, nicht für die BSDs!)
Du wirst nicht drum herum kommen, dich mindestens mit ACLs auseinander zu setzen, da die herkömmliche Rechteverwaltung selbst dabei hart an ihre Grenzen stoßen wird.
Also entweder, du investierst Zeit und bildest sich weiter, oder du musst damit leben, dass jedes Kind deinen Schutz umgehen kann. :)
Antivirenprogramme erkennen grundsätzlich nicht zuverlässig unbekannte Malware. (nur so 20% bis max. 40%)
Eine Firewall hilft hingegen effektiv auch gegen unbekannte Angriffe, sofern sie alle nicht benötigten eingehenden Ports verriegelt.
Allerdings solltest du in jedem Fall deine eigene Birne einsetzen. Auf Antivirensoftware kann man sich überhaupt nicht verlassen.