Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Ziffernkürzbare Zahlenpaare (Schleifen)

Normalerweise darf man aus Brüchen nicht einfach einzelne Ziffern kürzen. So ist 18/12 natürlich nicht gleich 8/2 (wenn ich die eins kürzen würde).

Bei einigen Zahlenpaaren funktioniert dies jedoch zufälligerweise. So ist (65/26) dasselbe wie 5/2 (einfach die Ziffer 6 im Zählen und Nenner steichen).

Schreiben Sie ein Programm, dass von allen zweistelligen Zahlenpaaren (Paare aus zwei zweistelligen Zahlen) angibt, ob die Zahl «ziffernkürzbar» ist.

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

2 Lösung(en)

package kuerzen; // 2019-11-25 ?

public class Kuerzen {

        public static void main(String[] arg) {
                new Kuerzen() . top2();
                new Kuerzen() . top3();
        }

        int x, y, z;
        void top2() {
                for(x = 1; x <= 9; x++) {
                        for(y=1; y <=9; y++) {
                                for(z = 0; z <=9; z++) {
                                        test();
                                }
                        }
                }
        }

        void test() {
                if(10*x*y+y*z == 10*y*z+x*z && x != y) {
                        System.out.println(""+x+z + "/" + y+x);
                }
        }

        int s, t, u;
        void top3() {
                for(x = 1; x <= 9; x++) {
                for(y = 0; y <= 9; y++) {
                for(z = 0; z <= 9; z++) {
                for(s = 1; s <= 9; s++) {
                for(t = 0; t <= 9; t++) {
                for(u = 0; u <= 9; u++) {
                        test3();
                }}}}}}
        }

        void spucksAus3() {
                System.out.println(""+x+y+z + "/" +s+t+u);
        }
        void test3() {
                int zaehlerOrig=100*x+10*y+z;
                int nennerOrig =100*s+10*t+u;

                // Trivialfälle aussortieren
                if(z==0 && u==0 && t==0) return;
                if(u==0 && y==0 && z==0) return;
                if(x==s && y==t && z==u) return;
                //nur aufsteigend
                if(nennerOrig<zaehlerOrig) return;

                if(x==t) {
                        if( (10*s+u)*zaehlerOrig == (10*y+z)*nennerOrig) {
                                spucksAus3(); return;
                        }
                }
                if(x==u) {
                        if( (10*s+t)*zaehlerOrig == (10*y+z)*nennerOrig) {
                                spucksAus3(); return;
                        }
                }
                if(y==s) {
                        if( (10*t+u)*zaehlerOrig == (10*x+z)*nennerOrig) {
                                spucksAus3(); return;
                        }
                }
                if(y==u) {
                        if( (10*s+t)*zaehlerOrig == (10*x+z)*nennerOrig) {
                                spucksAus3(); return;
                        }
                }if(z==s) {
                        if( (10*t+u)*zaehlerOrig == (10*x+y)*nennerOrig) {
                                spucksAus3(); return;
                        }
                }
                if(z==t) {
                        if( (10*s+u)*zaehlerOrig == (10*x+y)*nennerOrig) {
                                spucksAus3(); return;
                        }
                }
        }
}
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

// Kotlin

fun main() {
    for(a in 1..999) {
        for(b in 1..999) {
            if(a == b)
                continue

            isCancelable(a, b)
        }
    }
}

fun isCancelable(a: Int, b: Int) {
    val digitsA = getDigits(a)
    val digitsB = getDigits(b)
    val common = digitsA intersect digitsB

    cancel(a, b, digitsA, digitsB, common) {
        println("${it.first.first} / ${it.first.second} = ${it.second.first} / ${it.second.second}")
    }
}

fun cancel(originalA: Int, originalB: Int, a: List<Int>, b: List<Int>, common: Set<Int>, results: (Pair<Pair<Int, Int>, Pair<Int, Int>>) -> Unit) {
    for(cancel in common) {
        if(!a.contains(cancel) || !b.contains(cancel))
            continue

        if(a.size == 1 || b.size == 1)
            continue

        val newA = a.toMutableList().apply { remove(cancel) }
        val newB = b.toMutableList().apply { remove(cancel) }

        cancel(originalA, originalB, newA, newB, common, results)

        val aInt = newA.joinToString(separator = "").toInt()
        val bInt = newB.joinToString(separator = "").toInt()

        if(aInt.toDouble() / bInt.toDouble() == originalA.toDouble() / originalB.toDouble())
            results((originalA to originalB) to (aInt to bInt))
    }
}


fun getDigits(x: Int): List<Int> {
    val digits = mutableListOf<Int>()
    var i = x

    while (i > 0) {
        digits.add(i % 10)
        i /= 10
    }

    return digits.reversed()
}
                

Lösung von: Linus Götz (Lichtenberg-Gymnasium Cuxhaven)

Verifikation/Checksumme:

Zweistellig:

16/64
26/65
19/95
49/98

Dreistellig:

106/265
112/616
116/464
119/595
121/220
130/325
132/330
133/532
133/931
134/335
136/340
138/345
139/695
143/440
146/365
149/298
149/596
149/894
154/550
159/795
160/640
161/644
162/648
163/652
164/656
165/660
166/664
167/668
168/672
169/676
176/770
179/895
183/732
186/465
187/880
190/950
191/955
192/960
193/965
194/970
195/975
196/980
197/985
198/990
199/398
199/597
199/796
199/995
216/864
217/775
224/728
226/565
231/330
233/932
238/340
242/440
249/498
249/996
253/550
260/650
262/655
264/660
266/665
268/670
270/756
275/770
286/880
291/970
294/980
297/990
299/598
299/897
305/854
306/765
332/830
334/835
335/536
335/737
335/938
341/440
346/865
349/698
352/550
363/660
374/770
385/880
386/965
390/975
392/980
394/985
396/990
398/995
399/798
427/976
449/898
451/550
462/660
469/670
473/770
484/880
490/980
491/982
492/984
493/986
494/988
495/990
496/992
497/994
498/996
499/998
561/660
572/770
583/880
591/985
594/990
597/995
671/770
682/880
693/990
781/880
792/990
796/995
891/990

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 1
Schwierigkeit: Mittel
Webcode: 4tmw-rpud
Autor: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen