Kleine Code-Rätsel für Zwischendurch

Na ich hoffe mal, dass es hier sowas nicht schon gab.

Wie wäre es mit kleinen Code-Schnippseln, welche so kryptisch wie möglich geschrieben worden sind, aber sich auf wenige Zeilen beschränken (sagen wir 15 Zeilen maximal, so 2-Zeiler oder gar 1-Zeiler sind auch gern gesehen).

Kleines Beispiel:

int i = 3;
i+=++i/i++;

Welchen Wert hat "i"?

Natürlich ist dieses Beispiel besonders einfach und auch kann man die Ausgabe leicht selber erfahren, wenn man den Code mal ausführt. Aber ich finde das interessant anzusehen, was es so für kryptischen Code gibt, der eigentlich auch total simpel gestaltet werden kann.

Mein Lieblingsbeispiel, warum Klammern und Kommentare eben DOCH wichtig sind 😉:

++i+++++i++;

Zum Glück arbeiten wir ja in einem Umfeld wo auch andere den Code noch verstehen sollten und man nicht die kryptischste Schreibweise anwenden darf... 😉

Mein Lieblingsbeispiel, warum Klammern und Kommentare eben DOCH wichtig sind 😉:

++i+++++i++;  

Das blick ich schon nicht mehr 👍
Aber der Code muss auch ausführbar sein, ja? 😉

Okay, dann halt:

int i = 3;
i = ++i+++++i++;

So, und welchen Wert hat i nun 😉?

Mein Lieblingsbeispiel, warum Klammern und Kommentare eben DOCH wichtig sind 😉:

++i+++++i++;  

Hallo Golo,

in welcher Sprache ist das gültiger Syntax? Habs mit C# und C getestet und weder als Ausdruck noch als rhs Value ist das gültig 😉

Danke und Grüsse,
Egon

Mea culpa ... man muss es reduzieren zu:

int i = 3;
i = i+++++i;

C#:

test.cs(9,24): error CS1059: The operand of an increment or decrement operator must be a variable, property or indexer

Java:

test.java:8: unexpected type
required: variable
found   : value
                i = i+++++i;
                     ^
test.java:8: operator + cannot be applied to <any>,int
                i = i+++++i;
                       ^
test.java:8: incompatible types
found   : <nulltype>
required: int
                i = i+++++i;
                         ^
3 errors

C:

test.c:6: error: invalid lvalue in increment

Na rück schon raus, welche Sprache isses (das ist hier die eigentliche Frage ^^) 😉

Grüsse,
Egon

Also das hier

Mea culpa ... man muss es reduzieren zu:

int i = 3;  
i = i+++++i;  

lässt sich bei mir unter C# 2.0 kompilieren und ergibt als Resultat 8.

Also das hier

Mea culpa ... man muss es reduzieren zu:

int i = 3;  
i = i+++++i;  

lässt sich bei mir unter C# 2.0 kompilieren und ergibt als Resultat 8.

bei mir reklamiert es unter visual studio 2008

wenn ich aber

int i = 3;
i = i++ + ++i;

mach klappt es ohne probleme

Mea culpa ... man muss es reduzieren zu:

int i = 3;  
i = i+++++i;  

Das`s ja einfach Postinkrement von i ADDIERT mit dem Präinkrement von i:

int i = 3;
i = i++ + ++i;

kein Ding, kommt 8 raus..

Aber so:

int i = 3;
i = i+++++i;

...funktioniert es auch bei mir nicht.

Hallo Golo,

das ja mal interessant. Hab folgenden Code:

using System;
using System.Diagnostics;

public class Test
{
        public static void Main( string[] args )
        {
                int i = 3;
                i = i+++++i;
                Console.Out.WriteLine( i );
        }
}

weder der 2.0.50727, 3.5 noch der 1.9er gmcs (Mono) frisst den Code. Welche Compilerversion benutzt du genau?

Grüsse,
Egon

Ich könnte mir gut vorstellen, dass der Code i+++++i in Perl funktioniert 😉

Perl ist da echt unschlagbar...

Ich seh gerade, dass der Unterschied ist, dass VS bei mir den Code als

i++ + ++i

umformatiert. Ohne die Leerstellen funktioniert es bei mir auch nicht. Preisfrage ist nun, wieso die Leerstellen an dieser Stelle für den Compiler wichtig sind, ich dachte immer, die wären in C# egal?!?

Compilerversion ist 2.0.50727
VS-Version ist 8.0.50727.867 (vsvista.050727-8600)

In C# und C sind sie nicht egal! Absätze und mehrfache Leerstellen schon.

bei Perl müsste

i = i+++++i;

funktionieren!

EDIT: Bzw. eigentlich müssten sie doch egal sein, anscheinend nur bei dieser Mehrdeutigkeit nicht!?

Ich seh da keine Mehrdeutigkeit ... bei allen anderen arithemtischen Operationen ist es auch egal, ob ich

3+5

oder

3 + 5

oder

3    +        5

schreibe.

BTW: Übrigens, mit der Frage, warum das so ist, haben wir das nächste kleine Code-Rätsel 😉

Preisfrage ist nun, wieso die Leerstellen an dieser Stelle für den Compiler wichtig sind, ich dachte immer, die wären in C# egal?!?

... weils im ECMA-334 so spezifiziert ist 😉

Grüsse,
Egon

naja,

wenn ich i = i+++++i eingebe, macht er mir NICHT

i = i++ + ++i;

SONDERN

i = i++++ + i;

Er formatiert es schon falsch, weil er es nicht versteht.

Aber:

i = (i++)+(++i);

funktioniert...

Hallo zusammen,

eine Mehrdeutigkeit gibt es nicht und verstehen tut es der Compiler auch.

i = i+++++i

wird als

i = ((i++)++)+i

interpretiert und das gibt einen Fehler, weil das zweite ++ auf einen Ausdruck angewendet wird, was nicht geht.

herbivore

Hallo Herbivore,

danke für die Information!

(Ich komm mir grad irgendwie so vor: Kinners seit jetzt ruhig, Papa is da und erklärt euch jetzt mal wie das geht)

Grüsse,
Egon

Um mal wieder zum Thema zurück zu kommen 😁
Hab mal vor längerer Zeit auf meinen Übungsblättern der Informatik folgendes gesehen:
Gesucht ist ein vereinfachter Code:

static int mystery(int x, int y) {
    if (x < 0) return mystery(-x, -y);
    switch(x) {
        case 0: return x;
        default: return y + mystery(x - 1, y);
    }
}

Ist nicht sonderlich schwer, aber ich musste da doch etwas länger nachdenken was dass denn sein soll (2 durchläufe von bel. int).

Der Code kommt wahrscheinlich aus ner Vorlesung "Wie multipliziere ich zwei Zahlen möglichst umständlich" 🙂

2 durchläufe von bel. int

Was meinst du damit? Die Anzahl durchläufe der Funktion? Falls ja stimmt das nicht, die Funktion wird x+1 mal aufgerufen.

Aber hab auch was, wobei bei dem Rätsel fast übertrieben ist:

a^=b^=a^=b;

Was macht dieser Code in C und C++? (In C# funktioniert der nicht)

Und weil das kein C# war, mal ne kleine Verständnisfrage zu einem Code den ich in einem anderen Forum mal gepostet hab:

using System; 
using System.Threading; 
using System.Timers; 

namespace ConsoleApplication2 { 
    class Program { 
        static void Main(string[] args) { 

            bool abort = false; 
            System.Timers.Timer timer = new System.Timers.Timer(2500); 
            
            timer.Elapsed += (x,y) => { 
                timer.Stop(); 
                Console.WriteLine("Timer stops loop..."); 
                abort = true; 
            }; 
            
            Thread t = new Thread( () => { 
                    while (!abort) { 
                        Console.WriteLine("Hello from loop"); 
                        Thread.Sleep(250); 
                    } 
                } 
            ); 
            timer.Start(); 
            t.Start(); 
            t.Join(); 
            Console.WriteLine("Press Enter to exit"); 
            Console.ReadLine(); 
        } 
    } 
}

Die Frage ist, warum funktioniert dieser Code? Mit funktionieren meine ich, es wird ein Thread gestartet in der einfach eine Schleife läuft die in bestimmten Abständen Nachrichten ausgibt, und parallel dazu läuft ein Timer der den Thread nach einer bestimmten Zeit beendet. Es ist nicht so trivial wie er aussehen mag 🙂 Der Code benutzt zwar Lambda Expressions, aber es würde auch ganz normal mit anonymen Delegates funktionieren. Es gibt ein spezielles Feature was die Funktionsfähigkeit dieses Codes erst erlaubt, das würde ich gerne hören. (Das Feature ist auch nicht C# exklusiv, sondern kommt in einigen Sprachen vor, aber man liest zumindest hier im Forum kaum von, deshalb diese Frage nach dem Feature 🙂 )

Hallo,

wegen den Lambda-Ausdrücken?

Gruss
tscherno

Nein 🙂

...Der Code benutzt zwar Lambda Expressions, aber es würde auch ganz normal mit anonymen Delegates funktionieren...

Aber vielleicht um ein wenig die Richtung zu bekommen: was für eine Besonderheit gibt es denn bei diesem Code, bzw. wo müsste es eigentlich einen Fehler geben (wenn dieses Feature nicht vorhanden wäre).

EDIT: Meine Aussage dass man von diesem Feature hier nicht viel liest kann man durch die Forensuche untermauern 🙂 Es gibt tatsächlich nur einen einzigen Beitrag der dieses Feature beim Namen nennt und der ist aus dem Sommer 2005.

Hallo,

meinst du die besonderheit dass die variable "abort" in beiden threads zugänglich ist? falls es das ist weis ich aber trotzdem nicht wie das feature heißt...

mfg Markus

Ja, abort klingt gut - da steckt der Teufel im Detail 😉 Aber es hat an sich nichts mit den Threads zu tun, das ist hier nur ein Beispiel gewesen dass die Funktionen in verschiedenen Threads laufen.

EDIT: Noch als Anmerkung, diese Feature betrifft nicht nur abort, sondern auch den Timer, auch wenn es dort nicht so offensichtlich ist.

Und als kleinen Tipp noch, um auf das Problem hinzuweisen warum es da ein spezielles Feature gibt: Überlegt wie der Code mit normalen Eventhandler bzw. Thread Delegate aussehen würde statt mit anonymen Delegates bzw. Lambda Ausdrücken. Denke dann kommt man ganz leicht auf den eigentlichen Knackpunkt.

Möglichst kryptisch:

using C = System.Console;
class P
{
    static int Main()
    {
        int a = 52, r, c, i, v;
        bool[,] f = new bool[a, a], t;
        
        f[a/2, a/2] = f[a/2+1, a/2] = f[a/2+2, a/2] = f[a/2+1, a/2-1] = f[a/2, a/2+1] = 1>0;

        for (; ; f = t, C.Clear())
            for (r = 0, t = new bool[a, a]; ++r < a - 1; C.WriteLine())
                for (c = 0; ++c < a - 1; C.Write((t[r, c] = f[r, c] && --i == 2 || i == 3) ? "#" : " "))
                    for (v = i = 0; v < 9; ) if (f[r - 1 + v / 3, c - 1 + v++ % 3]) i++;
    }
}

Wers ohne probieren rausfindet, ist Gott 😜

Lg XXX

//Edit: damit man was gscheites sieht, muss die console vergrößert werden(vollbild)

Bevor jetzt jeder hier Rätsel postet würd ich vorschlagen dass die noch offenen erstmal gelöst werden, sonst würds arg unübersichtlich.

Momentan ist noch meine Frage und der Code von xxxprod offen zur Lösung.

Ich seh leider nichts (für mich) aussergewöhnliches...

Lg XXX

Hallo talla,

meinst du, dass abort eine captured variable ist? Der Begriff kommt allerdings mehrfach in der Forensuche vor.

herbivore

Ich denke auch er meint, dass abort in den 2 anonymen Methoden verwendet wird(so wie timer im Elapsed event). Würde man es nicht so Lösen, müsste man stattdessen eine Membervariable deklarieren für abort. Der Timer kommt ja eh beim Event mit (object sender).

Ist das die Auflösung?

Lg XXX

Der herbivore wieder 🙂

Captured variable ist ja eher beschreibend, das feature heist closures.

der trick bei dem code ist dass man auf dem ersten blick denken könnte das die abort variable selbstverständlich in den anonymen delegates vorhanden ist, da es ja im scope unter der abort variable liegt. Das ist aber gerade nicht der fall. Eigentlich könnte man nicht auf die zugreifen da es keine inneren funktionen gibt (wir sind immer noch in der main funktion, nicht im klassenscope) . Es wird auch eine anonyme klasse generiert die die anonymen methoden enthält. Da könnte man erst recht nicht auf die abort variable zugreifen.
damit man das doch logisch gesehen doch kann, dafür gibt es closures.

Okay, von mir auch noch ein Rätsel (ist jetzt der umgekehrte Weg, quasi von der Aufgabe zum gesuchten Code):

Wie kann man die Werte zweier Variablen tauschen, ohne eine dritte temporäre Variable zu nutzen UND ohne den ^-Operator zu verwenden?

in ein array laden und sortieren.

edit: oder durch eine verzögerte auswertung...

Auch das Array ist eine zusätzliche Variable 😉

Außerdem setzt das voraus, dass der zu tauschende Typ sortierbar ist ...

evtl mit dieser methode: Interlocked.Exchange-Methode im namespace System.Threading ?

edit: hier die signatur:

[ComVisibleAttribute(false)] 
public static T Exchange<T> (
    ref T location1,
    T value
)

Okay, ich sollte es noch etwas präzisieren: Gesucht wird eine 100% selbstgeschriebene Methode, die Eigenheiten von C# ausnutzt, um den Wert zweier Parameter zu vertauschen, ohne eine zusätzliche Variable oder externen Speicher wie eine Datei zu verwenden.

Ich habe es mit Labels getestet, deswegen sieht es etwas komisch aus^^
Funktioniert allerdings NUR MIT INTEGER!!!

private void exchangeVars()
        {
            lblVar2.Text = (Convert.ToInt16(lblVar1.Text) + Convert.ToInt16(lblVar2.Text)).ToString();
            lblVar1.Text = (Convert.ToInt16(lblVar2.Text) - Convert.ToInt16(lblVar1.Text)).ToString();
            lblVar2.Text = (Convert.ToInt16(lblVar2.Text) - Convert.ToInt16(lblVar1.Text)).ToString();
        }

ok das geht mit zahlen.
leserlich übersetzt:

int x = 5;
int y = 7;

x = x+y;
y = x-y;
x = x-y;

// x == 7
// y == 5

in der hinsicht, wäre dass mein vorschlag.
aber ich glaub Golo Roden sucht was anderes.

string var1 = "Var1";
string var2 = "Var2";

var1 += var2;

var2 = var1.Substring(0, var1.Length - var2.Length);
var1 = var1.Substring(var2.Length);

Nicht dumm, die Idee, war aber nicht das, was ich meinte ... aber trotzdem eine gute Lösung 🙂

Meine Lösung:

using System;
 
namespace SwapTest
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 23;
            int b = 7;
 
            b = Swap(a, a = b);
 
            Console.WriteLine(a);
            Console.WriteLine(b);
            Console.ReadKey();
        }
 
        private static int Swap(int a, int b)
        {
            return a;
        }
    }
}

Hallo Golo Roden,

deine Lösung benutzt allerdings gleich zwei zusätzliche Variablen, nämlich die Parameter a und b.

herbivore

Schließ mich Herbivore an, du benutzt die Parameter als temporäre Variablen.

Mich hat aber eher irgendwie diese Aussage verwirrt (abgesehen davon dass ich echt keine Idee hatte gg):

Okay, ich sollte es noch etwas präzisieren: Gesucht wird eine 100% selbstgeschriebene Methode, die Eigenheiten von C# ausnutzt, um den Wert zweier Parameter zu vertauschen, ohne eine zusätzliche Variable oder externen Speicher wie eine Datei zu verwenden.

Was für Eigenheiten werden da ausgenutzt? Das funktioniert mit fast jeder beliebigen Sprache.

Auch die Label oder Stringlösungen benutzen ja alle zusätzliche Variablen.
Aber vielleicht kann man das als Folgefrage anschließen: Gibt es denn überhaupt die Möglichkeit zwei Variablen zu tauschen ohne Zusatzvariable? Für Variablentausch kommt ja immer dieser Dreieckstausch als Standardlösung der universell funktioniert. Dann gibts noch den XOR Tausch

a^=b^=a^=b; 

(um auf die zweite kleine Frage in meinem Fragepost zurückzukommen gg) in z.B. C/C++ der a und b tauscht, welcher aber nicht in c# funktioniert, in VHDL kann man Werte von Signale leicht tauschen

a <= b;
b <= a;

Das funktioniert einfach so, da das ja direkt hardwaretechnisch abläuft und (das wäre jetzt eigentlich auch ne nette Frage gewesen, auch wenn es arg VHDL Kenntnisse vorrausgesetzt hätte) der "Speicher" die Leitung zwischen a und b ist wenn man sich a und b z.B. als FlipFlops vorstellt. CPUs bzw. allgemein µC haben ja spezielle Assemblerbefehle um Registerinhalte direkt zu tauschen. Ohne zusätzlichen Speicher dürfte es doch keine Möglichkeit geben, abgesehen davon irgendeine Hochsprache stellt den Registertausch Befehl direkt als Sprachfeature zur Verfügung.

Hallo,

hab auch noch was. Ist aber nicht von mir, bin mal zufällig darauf gestossen. Wenn es jemand rausfindet (ohne es zu kompilieren) dann ist er gut. 😁 (nicht Schummeln!)

Was macht dieses Programm?

using System;
using IAR = System.IAsyncResult;
using IE1 = System.Collections.IEnumerable;
using IE2 = System.Collections.IEnumerator;
using MRE = System.Threading.ManualResetEvent;
using PTS = System.Threading.ParameterizedThreadStart;

class P
{
    static void Main()
    {
        MRE fe = new MRE(false);
        MRE pe = fe;
        foreach( char c in new MSG() )
        {
            MRE ce = new MRE(false);
            PTS m = delegate(object s) { P p = (P)s; p.W.WaitOne(); Console.Write(p.C); p.G.Set(); };
            m.BeginInvoke(new P(c, pe, ce), delegate(IAR ar) { ((PTS)ar.AsyncState).EndInvoke(ar); }, m);
            pe = ce;
        }
        fe.Set();
        pe.WaitOne();
        Console.WriteLine();
    }

    public P(char c, MRE w, MRE g) { C = c; W = w; G = g; }

    char C;
    MRE W;
    MRE G;

    class MSG : IE1
    {
        public IE2 GetEnumerator()
        {
            int i = 0;
            foreach (char ch in new NTE<SM.B>()) yield return (i++ == 0 ? char.ToUpper(ch) : ch);
            yield return (',');
            yield return (' ');
            foreach (char ch in new NTE<SM.A>()) yield return (ch);
            yield return ('!');
        }
    }

    class NTE<PT> : IE1
    {
        public IE2 GetEnumerator()
        {
            foreach (Type t in typeof(PT).GetNestedTypes()) { yield return t.Name[t.Name.Length - 1]; }
        }
    }

    class SM
    {
        internal struct A
        {
            public struct cow { }
            public class too { }
            public interface car { }
            public enum will { }
            public struct pad { }
        }

        internal class B
        {
            public class wish { }
            public struct see { }
            public interface hill { }
            public enum ball { }
            public class boo { }
        }
    }
}

Ich poste morgen die Quelle.

Gruss
tscherno

Also... der Enumerator in new MRE() gibt auf alle Fälle mal "Hello, world!" zurück.

Das knifflige ist nur wie es ausgegeben wird.

Für jeden character wird ein async-delegate invoked, welches sich selbst blockiert und immer den nächsten freigeben kann.

Also

1. blockiert,
2. blockiert,
3. blockiert,
   .
   .
   .
   Nach der foreach Schleife wird der erste gesetzt welcher seinen character ausgiebt und das nächste delegate anstößt.
   Also
4. wird released, schreibt seinen char,
5. wird released, schreibt seinen char,
6. wird released, schreibt seinen char,
   usw....

Am Ende sollte wiederum "Hello, world!" rauskommen.

Hab ca, eine halbe Stunde dafür gebraucht.

Lg XXX

Hallo,

hier noch - leider etwas verspätet - der Link zur Quelle. (Sorry, hab nicht mehr dran gedacht...)

http://www.pluralsight.com/blogs/mike/archive/2006/09/25/38697.aspx

Gruss
tscherno

Okay, von mir auch noch ein Rätsel (ist jetzt der umgekehrte Weg, quasi von der Aufgabe zum gesuchten Code):

Wie kann man die Werte zweier Variablen tauschen, ohne eine dritte temporäre Variable zu nutzen UND ohne den ^-Operator zu verwenden?

In C / C++ kann man dafür einfach Assembler verwenden 🙂

int a = 2;
int b = 5;

asm{ 
     mov eax, a
     mov ebx, b
     mov b,eax
     mov a,ebx
};

eax und ebx sind Register, keine Variablen.

Da der letzte Beitrag schon etwas älter ist, stelle ich jetzt einfach mal eine Aufgabe^^

            byte i = 0x03;
            byte h = (++i & i++) == (--i & i--) ? i++ : ++i;
            Console.WriteLine("h ={0} | i = {1}", h, i); 

Wie lautet die Ausgabe? Natürlich sollte die Aufgabe im Kopf gelöst werden... Copy&Paste gilt nicht!^^

i = 0x03;

(i & i) == (--i & i--)
(a & b) == (c & d)

1.) a = i ==> i=4; a=4
2.) c = --i ==> i=3; c=3
3.) b = i ==> b=3; i=4
4.) d = i-- ==> d=4; i=3

i ist wieder 3 und a&b ist gleich c&d

Somit ist h=i++ ==> h=3< i=4

Ausgabe: h = 3 | i = 4

Wobei es auch sein kann das 1 und 2 bzw. 3 und 4 jeweils in umgekehrter Reihenfolge ausgeführt werden. (Ergebnis bleibt gleich)

Richtig und gut erklärt!

Bitte die nächste Aufgabe stellen^^