1. Dashboard
  2. Mitglieder
    1. Letzte Aktivitäten
    2. Benutzer online
    3. Team
    4. Mitgliedersuche
  3. Forenregeln
  4. Forum
    1. Unerledigte Themen
  • Anmelden
  • Registrieren
  • Suche
Alles
  • Alles
  • Artikel
  • Seiten
  • Forum
  • Erweiterte Suche
  1. AutoIt.de - Das deutschsprachige Forum.
  2. Mitglieder
  3. Xorianator

Beiträge von Xorianator

  • Best Practise: Dokumente als Ausgabe generieren

    • Xorianator
    • 14. Januar 2016 um 14:55

    @Alina ich denke primär ging es chesstiger nicht darum eine PDF zu erstellen bzw. eine ausfüllbare PDF zu haben, sondern diese zu generieren.
    Ihr redet aneinander vorbei.

    @chestiger mit LaTeX schießt du nicht mit Kanonen nach Spatzen, LaTeX scheint mir sogar die optimalste Lösung, wenn du es rein als plain-Text haben willst, der dann schön wird.
    Sicher, LaTeX ist mächtig, allerdings kümmert sich LaTeX auch um all deine Formatierungsprobleme die auftreten könnten. Würde dir empfehlen die Vorlagen in LaTeX zu schreiben und dann einfach mit einem Interpreter in eine PDF rausgeben lassen, nachdem du die Werte die ersetzt werden sollen ersetzt hast.
    Prinzipiell auch weil PDF das Universalformat ist, das bei jedem Endverbraucher abgerufen werden kann.
    Wer keinen PDF Viewer besitzt, der ruft die PDF einfach im Web auf.

  • Serwus aus Sachsen-Anhalt :P

    • Xorianator
    • 4. Januar 2016 um 19:36

    Grüße aus der Nachbarschaft, Thüringen, Jena.
    Willkommen und besten Erfolg :)

  • Script für barcodescanner

    • Xorianator
    • 9. Dezember 2015 um 08:56

    Hallo Shakoon,
    ich habe das so verstanden:
    Du hast es bereits geschafft den Wert deines Barcode Scanners auszulesen. Oder hast du das noch nicht implementiert?

    Zu dem "öffnen einer au3 Datei" - Du schreibst den Inhalt der Au3 Datei in eine Funktion, sodass du diese nur noch aufrufen musst, wenn du den Rückgabewert deines Scanners hast.

  • Script für barcodescanner

    • Xorianator
    • 9. Dezember 2015 um 08:33

    Heyho - Inkludiere doch einfach die Funktionen von Anfang an und rufe sie dann mit Execute() auf.

    Das sähe folgendermaßen aus:

    AutoIt
    Call("_Funktion" & StringReplace($barcodeWert, @CRLF, ""), $Param1, $Param2, $ParamN)

    Gruß

  • Happy Birthday, autoit.de!

    • Xorianator
    • 7. Dezember 2015 um 17:48

    Schließe mich an.
    Nach wie vor ein tolles Forum, auf hoffentlich etliche weitere Jahre :)
    Großen Dank auch an Gun-Food, peethebee, alle Moderatoren und Poweruser die hinter dem stehen, was wir präsentiert bekommen.
    Prost auf euch!

  • Forenvorschlag Kategorien.

    • Xorianator
    • 4. Dezember 2015 um 00:47

    Haben wir sowas nicht bereits?
    Zum einen ist die Kategorie "Hilfe & Unterstützung" genau das, nur dass hier einmal das Problem X vom Stellenden gezeigt wird, eine Teilmenge von Lösung Y vorgestellt wird und versucht wird den Fragestellenden dahin zu bringen dass er durch das Schiere nachdenken über die Frage zur Lösung kommt.
    Zum Anderen gibt es doch hier bereits "Mit" und "Ohne" Gegenleistung, wo für Problem X eine Lösung Y komplett gegeben wird. Allerdings ist das eher nicht für "kleine" Probleme anzusehen.Manchmal hilft es auch einfach mal 10 Minuten über das Problem nachzudenken, und nicht bei dem Schritt "Oh, das kann ich ja gar nicht lösen mit 'Kopf-Durch-Die-Wand'" direkt im Forum nachzufragen. Damit ist keinem Geholfen.
    €: Noch eine Anmerkung: Für A->B gibt es ja schon etliche UDFs, die man mit Googlen auch findet. Hier sei auch wieder der Text drüber erwähnt: 10 Minuten nachzudenken hilft oftmals (inkludiert: Googlen).
    Von daher meine Stimme dagegen.
    Grüße

  • Autoit - Gleitkommazahlen abrunden

    • Xorianator
    • 1. Dezember 2015 um 20:41
    Zitat von AspirinJunkie

    Vorsicht - gilt nur für positive Zahlen.Bei negativen Zahlen unterscheidet sich das Verhalten!


    Hallo AspirinJunkie - Selbstverständlich hast du Recht, was das Verhalten von Floor & Int angeht. In dem Falle müsste man ein "Ceiling" wählen.
    Dennoch bleibt der Effekt der gleiche: Das Int ist wieder schneller als die Rundungsoperatin selber.

    Demnach kann man nach wie vor festhalten, dass bei bekanntem Signum und gewolltem Floor / Ceiling die Geschwindigkeit des Int() schneller ist als die Geschwindigkeit von Floor() oder Ceiling().

    @Alina es geht hier nicht darum ob der Rechner schnell oder langsam ist. Ein gutes Ergebnis wäre in dem Fall die Tatsache dass es mit den nativen Floor & Ceiling Operationen schneller als Int ist sind.

  • Autoit - Gleitkommazahlen abrunden

    • Xorianator
    • 30. November 2015 um 17:38

    Gruß zur Stunde werte AutoIt Gemeinde,
    als ich mich mal mit der allgemeinen Typkonvertierung beschäftigte kam mir die Idee mal zu untersuchen welche Operationen in AutoIt schneller sind.
    Dafür verwendete ich folgendes, weitestgehend selbst erklärendes Script:

    Script
    AutoIt
    #include <Array.au3>
    
    
    ;------- PARAMETER
    Global $iNumbers = 10000
    Global $iDurchlaufe = 100
    ;-------
    
    
    Global $LeerVar = 0
    Dim $Numbers[$iNumbers]
    Dim $Ergebnisse[$iDurchlaufe][4]
    $TimerInt = TimerInit()
    
    
    
    
    For $rounds = 0 To UBound($Ergebnisse) - 1 Step 1
    	_GenerateNewNumbers($Numbers)
    	$TimerFloor = TimerInit()
    	For $i = 0 To UBound($Numbers) - 1 Step 1
    		$LeerVar = Floor($Numbers[$i])
    	Next
    	$Ergebnisse[$rounds][0] = TimerDiff($TimerFloor)
    
    
    	$TimerIntFloor = TimerInit()
    	For $i = 0 To UBound($Numbers) - 1 Step 1
    		$LeerVar = Int($Numbers[$i])
    	Next
    	$Ergebnisse[$rounds][1] = TimerDiff($TimerIntFloor)
    
    
    	$TimerCeiling = TimerInit()
    	For $i = 0 To UBound($Numbers) - 1 Step 1
    		$LeerVar = Ceiling($Numbers[$i])
    	Next
    	$Ergebnisse[$rounds][2] = TimerDiff($TimerCeiling)
    
    
    	$TimerIntCeiling = TimerInit()
    	For $i = 0 To UBound($Numbers) - 1 Step 1
    		$LeerVar = Int($Numbers[$i] + 1)
    	Next
    	$Ergebnisse[$rounds][3] = TimerDiff($TimerIntCeiling)
    
    
    	ConsoleWrite("Round: " & ($rounds + 1) & "/" & UBound($Ergebnisse) & @CRLF)
    Next
    Dim $Durchschnitt[6]
    For $i = 0 To UBound($Ergebnisse, 2) - 1 Step 1
    	For $i2 = 0 To UBound($Ergebnisse) - 1 Step 1
    		$Durchschnitt[$i] += $Ergebnisse[$i2][$i]
    	Next
    	$Durchschnitt[$i] /= UBound($Ergebnisse)
    Next
    $Durchschnitt[4] = "Nummern: " & $iNumbers
    $Durchschnitt[5] = "Durchläufe: " & $iDurchlaufe
    ;_ArrayDisplay($Ergebnisse)
    _ArrayDisplay($Durchschnitt)
    
    
    
    
    Func _GenerateNewNumbers(ByRef $input)
    	For $i = 0 To UBound($input) - 1 Step 1
    		$input[$i] = Random(0, 1000000000000)
    	Next
    EndFunc   ;==>_GenerateNewNumbers
    Alles anzeigen


    Da ich in diesem Script auch "Ceiling" untersuchte ist zu sagen, dass diese Variante nur für alle Zahlen außer ganze Zahlen gilt (ist ja logisch, sonst würde die +1 Methode nicht funktionieren). Also nehme ich an, dass keine Ganzzahl vor kommt bzw. wenn eine kommt das nicht behindern soll, da die Rundungsoperationen untersucht werden.
    Bei meinen Tests auf meinem i5-2500k unter Windows 8.1 64 Bit kam folgendes bei raus:
    Dabei wird das Ergebnis wie folgt beschrieben:
    [Blockierte Grafik: http://i.epvpimg.com/OXdRg.png]
    [0] = Floor
    [1] = Int
    [2] = Ceiling
    [3] = Int + 1

    Das Ergebnis bei Ceiling und Int + 1 erwartete ich eigentlich schon, da wir hier 2 Rechenoperationen ausführen und mich das nicht überraschend traf.
    Die Differenz von Floor zu Int hat mich dann allerdings doch überrascht. Wurde dieser Versuch mit 500.000 Zahlen geführt, so beträgt die Abweichung schon 10ms. Bei 50.000 führte ich sie ebenfalls durch, dabei betrug die Differenz 1ms.
    Um ein vernünftiges Ergebnis zu haben würde ich darum bitten dass hier mal ein paar Daten zusammen getragen werden und diese Abweichung nicht nur an meinem System liegt.

    Warum das Ganze?
    Nun - Man wird im Programmieralltag womöglich nie mit so einer Menge an zufälligen Zahlen, die dann auch noch abgerundet werden sollen, zu tun zu haben (zumindest nicht unter AutoIt). Dennoch interessierte mich diese Untersuchung, und als erstes Fazit nach mehreren Messungen kann ich sagen:


    Im Durchschnitt ist die Int Funktion der Floor Funktion zum abrunden vorzuziehen.

  • Renderings [nachträglich]

    • Xorianator
    • 29. November 2015 um 19:29

    Ja, kann es. Dafür sorgt die Jesus-Engine, welche beim rendern angewandt wurde.

  • [H] Timer von Router auslesen.

    • Xorianator
    • 24. November 2015 um 10:26

    Alternativ würde ich die _WinHTTP UDF empfehlen. Dann lässt sich das ganze recht einfach realisieren. Ich habe dir einen Tutorial Link dazu mal per PN geschickt.

  • PLA - Matrix Löser

    • Xorianator
    • 22. November 2015 um 14:43

    Gruß zum Sonntag,
    hier mal eine UDF zum lösen einer PLA-Matrix. Wer Lust und Laune hat, der kann gerne einen Simulator schreiben, mit dem man PLAs bauen kann und entsprechend die Ergebnisse durchkalkuliert und ausgibt.
    Da Dokumentation nicht ganz meine Stärke ist, versuche ich mich hier mal so klar wie möglich auszudrücken.

    Der erste Parameter ist ein PLA-Array, 3-Dimensional.
    Die erste Dimension des Arrays bestimmt die Anzahl der Reihen des PLA-Feldes.
    Die zweite Dimension des Arrays bestimmt die Anzahl der Spalten des PLA-Feldes.
    Die dritte Dimension besitzt 3 Elemente, welche die Eigenschaften & Zustände des PLA-Feldes angeben:
    [0] ist das Gatter, welches dieses Feld vertritt.
    [1] ist das X, welches dieses Feld annimmt
    [2] ist das Y, welches dieses Feld annimmt.
    Zur Initialisierung des Arrays wird das Feld mit [Zeilen] x [Spalten] aufgespannt und danach die Gatter belegt, also [0] einer Zeile x Spalte.
    Der zweite Parameter ist ein eindimensionales Array, in welchem ihr die Zustände eurer Eingabevariablen gespeichert sind. Hier entspricht die erste Zeile auch der ersten Zeile eures Gatters (in der Pdf: [0] = x, [1] = y, [2] = z).

    Die solvePLAMatrix Funktion errechnet selbst, wo sich die UND und ODER Ebene voneinander trennt. Daher muss lediglich die Matrix sowie die Eingabevariablen übergeben werden.

    Als Ergebnis erhaltet ihr einen 1-Dimensionalen Array zurück, der folgenden Aufbau hat:
    [0...Anzahl der Eingabevariablen] = die Rückgabewerte der UND-Zeilen, also im Prinzip x1, x2, x3, x...
    [/\ + 1] = "---" - Einfach nur ein Trennstrich, falls man die Ergebnisse durchlaufen will ohne die Matrix zu kennen
    [/\ + 1..Größe der ODER-Zeilen] = das Ergebnis der Funktion f1, f2, f3, ...
    [/\ + 1] = "---" wieder ein Trennstrich, falls man die Ergebnisse der Funktionen durchlaufen will ohne die Matrix zu kennen
    [/\ + 1..Anzahl der Spalten] = Die Ausgabe der einzelnen Konjunktionen

    Viel Gerede, vermutlich nicht ganz einleuchtend, also habe ich mal was kleines aufgemalt um es verständlich(er) zu machen:
    [Blockierte Grafik: http://i.epvpimg.com/xCFxd.png]

    UDF:

    plaMatrixSolver.au3
    AutoIt: plaMatrixSolver
    Func solvePLAMatrix($inputMatrixPLA, $aInputs)
        Local $matrixPLA = $inputMatrixPLA
        Local $outputArray[UBound($matrixPLA) + UBound($matrixPLA, 2) + 2]
        Local $actualPLAArray
        For $actualRow = 0 To UBound($aInputs) - 1 Step 1
            $actualPLAArray = getPLAValues($matrixPLA[$actualRow][0][0], ($actualRow = 0 ? 1 : $matrixPLA[$actualRow - 1][0][1]), $aInputs[$actualRow])
            $matrixPLA[$actualRow][0][1] = $actualPLAArray[0]
            $matrixPLA[$actualRow][0][2] = $actualPLAArray[1]
            If ($actualRow = 0) Then
                For $actualColumn = 1 To UBound($matrixPLA, 2) - 1 Step 1
                    $actualPLAArray = getPLAValues($matrixPLA[$actualRow][$actualColumn][0], 1, $matrixPLA[$actualRow][$actualColumn - 1][2])
                    $matrixPLA[$actualRow][$actualColumn][1] = $actualPLAArray[0]
                    $matrixPLA[$actualRow][$actualColumn][2] = $actualPLAArray[1]
                Next
            Else
                For $actualColumn = 1 To UBound($matrixPLA, 2) - 1 Step 1
                    $actualPLAArray = getPLAValues($matrixPLA[$actualRow][$actualColumn][0], $matrixPLA[$actualRow - 1][$actualColumn][1], $matrixPLA[$actualRow][$actualColumn - 1][2])
                    $matrixPLA[$actualRow][$actualColumn][1] = $actualPLAArray[0]
                    $matrixPLA[$actualRow][$actualColumn][2] = $actualPLAArray[1]
                Next
            EndIf
            $outputArray[$actualRow] = $matrixPLA[$actualRow][UBound($matrixPLA, 2) - 1][2]
        Next
        $outPutArray[UBound($aInputs)] = "---"
        For $actualRow = UBound($aInputs) To UBound($matrixPLA) - 1 Step 1
            $actualPLAArray = getPLAValues($matrixPLA[$actualRow][0][0], $matrixPLA[$actualRow - 1][0][1], 0)
            $matrixPLA[$actualRow][0][1] = $actualPLAArray[0]
            $matrixPLA[$actualRow][0][2] = $actualPLAArray[1]
            For $actualColumn = 1 To UBound($matrixPLA, 2) - 1 Step 1
                $actualPLAArray = getPLAValues($matrixPLA[$actualRow][$actualColumn][0], $matrixPLA[$actualRow - 1][$actualColumn][1], $matrixPLA[$actualRow][$actualColumn - 1][2])
                $matrixPLA[$actualRow][$actualColumn][1] = $actualPLAArray[0]
                $matrixPLA[$actualRow][$actualColumn][2] = $actualPLAArray[1]
            Next
            $outputArray[$actualRow + 1] = $matrixPLA[$actualRow][UBound($matrixPLA, 2) - 1][2]
        Next
        $outputArray[UBound($matrixPLA) + 1] = "---"
        For $actualColumn = 0 To UBound($matrixPLA, 2) - 1 Step 1
            $outputArray[UBound($matrixPLA) + 2 + $actualColumn] = $matrixPLA[UBound($matrixPLA) - 1][$actualColumn][1]
        Next
        Return $outputArray
    EndFunc   ;==>solvePLAMatrix
    ;uvArray[0] = v
    ;uvArray[1] = u
    Func getPLAValues($typePLA, $x, $y)
        Local $uvArray[3]
        $uvArray[2] = $typePLA & "|" & $x & "|" & $y
        Local Const $IDENTER = 0
        Local Const $ADDER = 1
        Local Const $MULTIPLER = 2
        Local Const $NEGAT_MULTIPLER = 3
        Switch $typePLA
            Case $IDENTER
                $uvArray[0] = $x
                $uvArray[1] = $y
            Case $ADDER
                $uvArray[0] = $x
                $uvArray[1] = ($x Or $y) * 1
            Case $MULTIPLER
                $uvArray[0] = $x * $y
                $uvArray[1] = $y
            Case $NEGAT_MULTIPLER
                $uvArray[0] = ($x And (Not $y)) * 1
                $uvArray[1] = $y
        EndSwitch
        Return $uvArray
    EndFunc   ;==>getPLAValues
    Alles anzeigen


    Damit es vielleicht einleuchtend wird, wie alles aufgebaut ist, hier auch nochmal ein Script welches es für das Beispiel auf dem Papier zeigt:

    Beispiel.au3
    AutoIt
    #include <Array.au3>
    #include "plaMatrixSolver.au3"
    ;-1 ist dem Aufbau der For geschuldet, ist natürlich
    ;kein korrekter Zustand für ein Binäres Array
    Local $Binarys[4] = [0, 0, 0, -1]
    Local $plaMatrix[5][2][3]
    $plaMatrix[0][0][0] = 0
    $plaMatrix[0][1][0] = 3
    $plaMatrix[1][0][0] = 3
    $plaMatrix[1][1][0] = 2
    $plaMatrix[2][0][0] = 3
    $plaMatrix[2][1][0] = 0
    $plaMatrix[3][0][0] = 0
    $plaMatrix[3][1][0] = 3
    $plaMatrix[4][0][0] = 1
    $plaMatrix[4][1][0] = 1
    For $i = 0 To 15 Step 1
        $Binarys = addOneBinary($Binarys)
        _ArrayDisplay(solvePLAMatrix($plaMatrix, $Binarys))
    Next
    Func addOneBinary($arrayBinary)
        Local $newBinary = $arrayBinary
        $newBinary[UBound($newBinary) - 1] += 1
        For $i = UBound($newBinary) - 1 To 0 Step -1 ;Von rechts gelesen
            If ($newBinary[$i] == 2) Then
                $newBinary[$i] = 0
                If ($i - 1 >= 0) Then
                    $newBinary[$i - 1] += 1
                EndIf
            EndIf
        Next
        Return $newBinary
    EndFunc   ;==>addOneBinary
    Alles anzeigen

    Wer Lust und Laune hat kann ja einen Simulator schreiben, mit dem man die PLAs sowie Eingabewerte direkt in der GUI erstellen kann und sich die Ergebnisse ausgeben lassen kann.
    Grüße - Xorianator

    Dateien

    Beispiel.au3 947 Byte – 456 Downloads plaMatrixSolver.au3 2,99 kB – 439 Downloads
  • Zukunft für AutoIt.de - Impressionen und Ideen

    • Xorianator
    • 3. Juli 2015 um 23:31

    Ich ziehe meinen Hut vor Gun-Food und allen, die dazu beitragen das Forum hier wieder auf den "alten" Zustand zu versetzen.
    Trotz Familie & Arbeit den Schuppen zu schmeißen verdient vollsten Respekt!
    Danke dir, danke euch!

  • Variable als INI behandeln?

    • Xorianator
    • 15. April 2015 um 22:58

    @Kanashius drücke mal "STRG+T" in SciTE, dann wird dein Code auch ordentlich formatiert :)

  • Revision 2015

    • Xorianator
    • 5. April 2015 um 15:56

    [Blockierte Grafik: http://i.epvpimg.com/EMP9g.png]Der Andy.
    Der Kopf rechts über seiner Schulter präsentiert UEZ :D

    So, jetzt kann mans auch endlich mal lesen:
    [Blockierte Grafik: http://i.epvpimg.com/hvksc.png]

  • primzahlenrechner

    • Xorianator
    • 29. März 2015 um 10:27

    Da ich ja gerade in Java unterwegs bin, habe ich den Code von @Andy mal in einem Java-Programm untergebracht:

    Java
    package primeregex;
    
    
    import java.util.regex.Pattern;
    import java.util.regex.Matcher;
    
    
    /**
     *
     * @author Xoria
     */
    public class Primeregex {
    
    
        /**
         * @param args the command line arguments
         */
        public static void main(String[] args) {
            StringBuilder primeString = new StringBuilder("1");
            Pattern primePattern = Pattern.compile("^1?$|^(11+?)\\1+$");
            for(int i = 3; i < 3000; i+=2){
                primeString.append("11");
                Matcher primeMatcher = primePattern.matcher(primeString.toString());
                if(!primeMatcher.matches()){
                    System.out.println("i = " + i);
                }
            }
        }
    
    }
    Alles anzeigen


    Falls sich jemand wundert, warum in Zeile 17 das "\" durch "\\" ersetzt wurde: In Java muss das "\" um als "\" zu funktionieren auch ausgeklammert werden.
    Bei 10.000 Primzahlen schafft er es innerhalb von - sage und schreibe - 6 Sekunden...

  • [Sammelthread] Fangfragen, Rätsel & Co

    • Xorianator
    • 28. März 2015 um 23:45

    Und wieder eins, nicht allzu schwer, lässt sich im Notepad recht einfach lösen:
    Eine Zahl mit 8 Ziffern ist gesucht.
    Diese Zahl besteht aus 2 Einsen, welche je eine Zahl Abstand zueinander haben. 2 Zweien, welche je 2 Zahlen Abstand zueinander haben. 2 Dreien, welche je 3 Zahlen Abstand zueinander haben und 2 Vieren welche je Vier Zahlen Abstand zueinander haben. (Also 1 * 1, 2 * * 2, 3 * * * 3, 4 * * * * 4)

    Lösung


    4 1 3 1 2 4 3 2 - Oder rückwärts

    Noch ein Rätsel:
    Ein Weihnachtswichtel schreibt in der dunkelsten Nacht 3 Briefe, welche an 3 verschiedene Personen gehen. Er hat die 3 Briefumschläge bereits beschriftet, die Briefe aber noch nicht in die Umschläge gesteckt. Plötzlich fällt der Strom aus und es gibt kein Licht mehr. Er ist zu faul, sich Licht zu machen und steckt auf "Gut Glück" die Briefe in die Umschläge, weiß aber nicht, ob diese richtig eingesteckt sind.
    Wie hoch ist die Wahrscheinlichkeit, dass genau 2 von 3 Briefen richtig eingetütet wurden?

    Lösung 2


    Natürlich 0%. Im Falle dessen, dass 2 richtig sind, ist auch der 3. richtig.
    Wer sich immer noch wundert: In der Aufgabenstellung stand genau 2 von 3.

  • [Sammelthread] Fangfragen, Rätsel & Co

    • Xorianator
    • 28. März 2015 um 22:32
    Spoiler anzeigen


    @Rätsel 1: Das kenne ich bereits, es ist Tag, deshalb sind auch der Mond und die Sterne nicht zu sehen.
    @Rätsel 2: Ich musste passen, deshalb schreibe ich die Lösung hier nicht hin, nur einen Tipp: Es hat nix mit Mathematik zu tun :D
    @Rätsel 3: Nadelöhr? Hat ja auch Löcher und hält :D
    @Rätsel 4: Hmmm... Ich würde jetzt sagen die 4, weil "13375P34K", "3.14" und "42"

  • [Sammelthread] Fangfragen, Rätsel & Co

    • Xorianator
    • 28. März 2015 um 21:41

    Na dann, hier mal ein leichtes Bildrätsel:
    [Blockierte Grafik: http://cdn1.spiegel.de/images/image-822140-breitwandaufmacher-tjvj.jpg]
    Die Kirsche soll außerhalb des Glases sein, es ist aber nicht erlaubt (wie rechts zu sehen) das Glas einfach umzudrehen. Um die Kirsche heraus zu befördern dürfen nur !2! Streichhölzer bewegt werden.

  • [Sammelthread] Fangfragen, Rätsel & Co

    • Xorianator
    • 28. März 2015 um 21:02

    Mal ein kleines Logikrätsel für euch:
    3 Personen sind zum Tode verurteilt. Der Richter gibt ihnen eine Chance, freigesprochen zu werden, wenn sie die folgende Aufgabe richtig erfüllen:
    - Die 3 Personen sitzen in einer Reihe hintereinander. Sie sehen jeweils die Vordermänner (der ganz vorne sieht also keinen).
    - Zwei der Personen haben eine schwarze Mütze auf und einer trägt eine weiße Mütze.
    - €DIT: Natürlich kann keiner seine eigene Mütze sehen, umgedreht werden darf sich auch nicht.
    Derjenige, der die weiße Mütze auf dem Kopf hat, muss es sagen. Sagt es eine Person mit einer schwarzen Mütze, so haben sie verloren.
    Ist diese Aufgabe lösbar? In welchen Fällen ist sie lösbar?

    Viel Spaß beim knobeln (es ist noch ein recht anspruchsloses Rätsel :D)

  • Link öffnen, Bild speichern - 15 Euro

    • Xorianator
    • 22. März 2015 um 20:07

    Sage uns doch einfach mal die Domain.
    Das ganze lässt sich über HTTP viel einfacher, schneller und im Hintergrund erledigen (ohne dass auf dem Bildschirm rumgeklickt wird) :)

Spenden

Jeder Euro hilft uns, Euch zu helfen.

Download

AutoIt Tutorial
AutoIt Buch
Onlinehilfe
AutoIt Entwickler
  1. Datenschutzerklärung
  2. Impressum
  3. Shoutbox-Archiv
Community-Software: WoltLab Suite™