Hilfe 1*1 !

[BlackJack]

6510-Assembler für den `xa65`-Crossassembler und dem C64 als Zielplattform:

Code: Alles auswählen

    .zero
a       .byte 0
b       .byte 0
c       .byte 0

    .text
    .word $1000
    *=$1000
    
    lda #1      ; a = 1
    sta a
    
outer_loop
    ldx #1      ; b = 1
    stx b
    dex         ; c = 0
    stx c
    
    lda #13     ; print newline before block
    jsr $ffd2
inner_loop
    clc         ; c += a
    lda c
    adc a
    sta c
    
    ldx b       ; print b
    jsr print_byte
    
    lda #'*'    ; print "*"
    jsr $ffd2
    
    ldx a       ; print a
    jsr print_byte
    
    lda #'='    ; print "="
    jsr $ffd2
    
    ldx c       ; print c
    jsr print_byte
    
    lda #13     ; print newline
    jsr $ffd2
    
    inc b       ; b += 1
    lda #11     ; if b != 11 then repeat loop
    cmp b
    bne inner_loop
    
    inc a       ; a += 1
    cmp a       ; if b != 11 then repeat loop
    bne outer_loop
    
    rts         ; bye...

;---------------------------------
; Print byte value in X register.
print_byte
    lda #0
    jmp $bdcd

[EyDu]

Dann will ich mal eine C++-Lösung beisteuern.

Code: Alles auswählen

#include <iostream>

template <int M, int N>
struct Value {
    static void print() { std::cout << M << " * " << N << " = " << M*N << std::endl; }
};

struct Null {
    static void print() { };
};

template <typename H, typename T>
struct List {
    typedef H Head;
    typedef T Tail;
    
    static void print() { Head::print(); Tail::print(); }
};

template <int M, int I, int X>
struct Range {
    typedef List<Value<M, X>, typename Range<M, I-1, X+1>::Result> Result;
    static void print() { Result::print(); }
};

template <int M, int X>
struct Range<M, 0, X> {
    typedef Null Result;
    static void print() { }
};

template <int M, int N, int X>
struct Row {
    typedef List<typename Range<X, N, 1>::Result, typename Row<M-1, N, X+1>::Result> Result;
    static void print() { Result::Head::print(); Result::Tail::print(); }
};

template <int N, int X>
struct Row<0, N, X> {
    typedef Null Result;
    static void print() { }
};

template <int N, int M>
struct Result {
    typedef Row<N, M, 1> Data;
    static void print() { Result::print(); }
};

int main(int argc, char **argv) {
    Result<10, 10>::Data::print();
}

Edit: Eigentlich kann man die Listen auch gleich weglassen.

Code: Alles auswählen

#include <iostream>

template <int M, int N>
struct Mult {
    static void print() {
        std::cout << M << " * " << N << " = " << M*N << std::endl;
    }
};

template <int M, int X, int I>
struct Inner {
    static void print() {
        Mult<M, X>::print();
        Inner<M, X+1, I-1>::print();
    }
};

template <int M, int X>
struct Inner<M, X, 0> {
    static void print() { }
};

template <int M, int X, int I>
struct Outer {
    static void print() {
        Inner<X, 1, M>::print(); Outer<M, X+1, I-1>::print();
    }
};

template <int M, int X>
struct Outer<M, X, 0> {
    static void print() { }
};

template <int M>
struct Einmaleins {
    static void print() { Outer<M, 1, M>::print(); }
};

int main(int argc, char ** argv) {
    Einmaleins<10>::print();
}

[Trichter]

Wann kommt der Brainf*** Code!?

[Nebelhom]

hehe, ich warte noch auf ein mit Piet gemaltes bild?

[frabron]

Ich hab noch PHP im Angebot

Code: Alles auswählen

<?php
foreach(range(1,10)as $a) {
        foreach(range(1,10) as $b) {
                print "$a x $b = ".$a*$b."\n";
        }
}
?>

[Xynon1]

Pah, PHP, hier kommt Brainfuck

Code: Alles auswählen

++++++++++>>++++++[<+++++++>-]+>++++++[<++++++++++>-]>++++[<++++++++>-]>>+>>+><
<<<++++++++++[<++++++++++>-]<[>>>>><<<<[>>>>>>+>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>
>>-]<-[<<+>+>-]<<[>>+<<-]+>[<->[-]]<[<<<<->>>>[-]]>[-]>[-]>[-]<<<<<<<<-[>>>>>+>
+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<>++++++++++<[->>+<-[>>>]>[[<+>-]>+>>]<<<<<]<<<[
-]++++++++++>>>>>[<<<<<->>>>>-]<<<[-]++++++++++>>>>[<<<<->>>>-]<<<<<<[>>>>>>>+>
+<<<<<<<<-]   >>>>>   >>>[<<<<<<<<+>>>>>>>>-]++++++++++[<->-]<<<[-]>[-]>[<<+>+>
-]<<[>>+<<-]   +>[   <->[-]]<[<<<<<---------<[>>>>>>>+>+<<<<<<<<-]>>>>>>>>[<<<<
<<<<+>>>>>>>>   -   ]<<[   -]<[-]   >  >    [<<+>+>     -]<<[  >    >+<<-]+>[<<
<<<<->>>>>>->[     -]]<[<   <<<-   <+    >   >>>>   -]>   [-]    ]   <<[-]>[-]>
[-]>[-]>[-]<<<<   <[>>>>>+   >+   <<<  <<<-   ]>   >>>>>   [<  <<<<   <+>>>>>>-
]++++++++++[<-     >-]<<<[-      ]>[-  ]>[<<  +>  +>-]<<[  >>  +<<-]  +>[<->[-]
]<[<<<-------   -   --<[-]+>    >>>[-  ]]<<[  -]   >[-]>   [-  ]>[-]  >[-]>[-]<
<<++++[<<<<<   <[>   >>>+>+<<  <<<-]>  >>>>[  <<<   <<+   >>>  >>-]+  +++++[<++
++++++>-]>-   [>+<-   ]>]<<<<  <<.>.<  <<<<<  <.<<.     >>.>>  >>>>>  >.>.<<<<<
<<<<.<.>.>>>>>>>>>>+++++  ++  +++++[<----<----<----<---->>>>-]<<<<[>>>>++++++++
++<<<<-]>[>>>+<<<-]>[>>>+    +++++++++<<<-]>[>>+<<-]>[>[>+>+<<-]>>[<<+>>-]<<<-]
>>>>++++++++++[<++++++++++  >-]<<[->>+<-[>>>]>[[<+>-]>+>>]<<<<<]>>>[-<<<<<<<<+>
>>>>>>>]++++++++++<[->>+<-[>>>]>[[<+>-]>+>>]<<<<<]>>>[-<<<<<<<<<+>>>>>>>>>]<[-<
<<<<<<+>>>>>>>]<<<<<<[-]>[-]>[-]>[-]<<<<<<<++++++++++++[>++++>++++>++++<<<-]>.>
.>.<<<<<<<<<<<<.>>>>>>>>>[-]>[-]>[-]>[-]>[-]>[-]>[-]>[-]>[-]>[-]<<<<<<<<<<<<<<]

Edit: Hab mal noch ein paar Sachen gekürzt, wenn jemand noch etwas sieht, was sich weg rationalisieren läßt, her damit
Edit2: Nochmal etwas gekürzt und ein schöneres Layout verpasst

[frabron]

Postgresql SQL

Code: Alles auswählen

select a, b, a*b as result from generate_series(1,10) as a(a), generate_series(1,10) as b(b)

[mutetella]

Oh mein Gott.... wie seid ihr denn drauf?

[Xynon1]

Na, bestens gelaunt und völlig erledigt(Ich für meinen Teil zumindest), vorallem mein Gehirn. Habe gestern den Abend von 22:30-ca. 2:00Uhr an diesem verdammten Script gesessen und heute meine Mittagspause damit verbracht es fertig zustellen

[syntor]

Na, bestens gelaunt und völlig erledigt(Ich für meinen Teil zumindest), vorallem mein Gehirn. Habe gestern den Abend von 22:30-ca. 2:00Uhr an diesem verdammten Script gesessen und heute meine Mittagspause damit verbracht es fertig zustellen

Aus einem Grund nennt sich die Sprache ja auch Brainfuck

[problembär]

Perl-Einzeiler (ginge bestimmt noch kürzer):

Code: Alles auswählen

perl -e 'for(1..10){for $j(1..10){print"\n$_ x $j = ".$_*$j}print"\n"}'

[derdon]

Laut wc (ohne Optionen aufgerufen) 101 Zeichen mit Golfscript:

Code: Alles auswählen

1:i;{i 10>}{1:j;{j 11<}{j print' x 'print i print' = 'print i j*p j):j;}while n print i):i;}until

Edit: 98 Zeichen

[Hyperion]

Edit: 98 Zeichen

Wow, da führt ja meine Basic-Variante mit 59 (respektive BJs Anmerkung 57) Zeichen klar

Ok, Die Länge von BlackJacks Assembler Kompilat könnte da drunter liegen...

[derdon]

Das liegt wahrscheinlich erstens an meinem redundanten Einsatz von print und zweitens an der generellen Herangehensweise (die Art, verschachtelte Schleifen zu verwenden statt map / each). Ich bin mir sicher, dass eine Lösung in weniger als 20 Zeichen in Golfscript möglich ist. Ist halt mein erstes Skript in Golfscript. Solche Wettbewerbe eignen sich gut als Übung

[b.esser-wisser]

Beim golfen kann awk auch gerade so mitmachen:

Code: Alles auswählen

$ awk 'BEGIN{for(i=1;i<=10;++i)for(j=1;j<=10;++j)print i" x "j" = "i*j}'

Sieht aber aus wie alle C-Artigen - bis auf den sprichwörtlich nicht vorhandenen Stringverkettungsoperator.

[derdon]

Immerhin runter auf 81:

Code: Alles auswählen

1:i;{i 10>}{1:j;{j 11<}{j' x 'i' = 'i j*++++puts j):j;}while n print i):i;}until

[BlackJack]

@Hyperion: Naja, eigentlich zählt ja die Quelltextgrösse und da ist das Assemblerprogramm viel zu gross um Konkurrenzfähig zu sein.

Das übersetze Assembler-Programm ist 75 Bytes gross (73 Bytes Code + 2 Bytes Startadresse).

Und wenn man die Dateigrösse als Grundlage nimmt, dann ist Dein BASIC-Programm nur 43 Bytes gross, wenn ich mich nicht verzählt habe. Die BASIC-Schlüsselwörter werden jeweils in nur einem Byte gespeichert. Plus Startadresse, 2 Byte-Zeilennummer, 2 Byte Pointer auf den Anfang der nächsten Zeile, Nullbyte zum Abschluss der Zeile und zwei Nullbyte die das Ende des Programms markieren (darauf zeigt der "Nächste-Zeile"-Pointer).

Bei dem BASIC bekommt man den Quelltext selbst aber sogar unter die Dateigrösse, weil man die meisten Befehle bei der Eingabe mit zwei Zeichen abkürzen kann. ``PRINT`` sogar mit einem ``?``:

Code: Alles auswählen

0fOa=1to10:fOb=1to10:?b"x"a"="a*b:nE:?:nE

[lunar]

Ich hätte noch (SWI-)Prolog zu bieten:

Code: Alles auswählen

timestable(X,Y,XY) :- between(1, 10, Y), between(1, 10, X), XY is X*Y.

writetimestable :-
    forall(timestable(X,Y,XY), writef("%3r * %3r = %3r\n", [X, Y, XY])).

[b.esser-wisser]

Das 'Problem' kann man doch parallelisieren:

Code: Alles auswählen

#include <stdlib.h>
#include <stdio.h>
#include <omp.h>

#define MAX 10
int main(void)
{
    puts("Das Einmaleins");
    for(int i=1; i <= MAX; ++i) {
        int result;
#pragma omp parallel for private (result)
        for(int j=1; j <= MAX; ++j) {
            result = i*j;
#pragma omp critical
            {
                printf("%d x %d = %d\n", i, j, result);
            }
        }
    }
    return EXIT_SUCCESS;
}

Ich wollte bloß wissen, ob mein mingw32 opemMP unterstützt (ja, mit dem Parameter '-fopenmp') -und die Ausgabe sieht nicht genau aus wie gefordert

[Hyperion]

lol Nice!

Interessant wäre es zu bestimmen, ob bzw. ab welchem Wert von MAX es sich lohnt Bei einer simplen Multiplikation wird man da wohl erst weit nach der Integer Grenze einen Benefit spüren...