Scripting Contest

[inne]

Hier nun meine Lösung, wie gesagt ohne Fehlerbehandlung.
Es müssen also immer auch die Nachkommastellen mit angegeben werden.

Bin gespannt, wie andere das rechnen!

Code: Alles auswählen

// Die Character beginnen bei 48 + abgebildeter Zahlwert 0 bis 9
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[]) {
	double dbl, multipli;
        char *str = argv[1], *c = index(str, '.');
	size_t end;

	multipli = 1;
	end = str - 1;
	for (char *i = c - 1; i > end; i-- ) {
	        dbl      += (str[i-str] - '0') * multipli;
		multipli *= 10;
	}

	multipli = .1;
	end = str + strlen(str);
	for (char *i = c + 1; i < end; i++ ) {
		dbl      += (str[i-str] - '0') * multipli;
		multipli /= 10;
	}

	printf("number is: %.3lf\n", dbl);
}

PS: Nachdem Meillo mir nochmal die Syntax zum Rechnen mit Zeigern in C gezeigt hat, lasse ich meine Lösung mit strtok weg. Welche auch langsamer war.

[Meillo]

Ach ja, da war ja noch so eine Programmieraufgabe.


Hier meine Umsetzung:

Code: Alles auswählen

#include <stdio.h>
#include <ctype.h>

int
main(int argc, char *argv[])
{
        double num=0.0, dec=0.0;
        int n, decimal=0, found=0;
        char *c;

        if (argc != 2) {
                fprintf(stderr, "Usage: %s NUMBER\n", argv[0]);
                return 1;
        }

        for (c=argv[1]; *c; c++) {
                if (*c == '.' && !decimal) {
                        decimal = 1;
                        continue;
                } else if (!isdigit(*c)) {
                        break;
                }
                found = 1;
                n = *c - '0';
                if (decimal) {
                        dec *= 10;
                        dec += n;
                        decimal++;
                } else {
                        num *= 10;
                        num += n;
                }
        }
        if (!found || *c || *(c-1) == '.') {
                puts("no number");
                return 1;
        }
        while (decimal-- > 1) {
                dec /= 10;
        }
        printf("number is: %.3lf\n", num + dec);
        return 0;
}

Die while-Schleife wollte ich mir eigentlich noch sparen, indem ich das Dezimalverschieben gleich oben mache, allerdings hatte ich dann keine Lust mehr darauf, weiter rumzuprobieren ...

Wenn ich jetzt innes Ansatz aufgreifen wuerde, waere das wohl kein Problem mehr. Ich war damals bloss zu doof dazu, zu sehen wie einfach es geht.

... und inne hat nicht gesehen, dass es auch ganz einfach ist, den Ganzzahlteil von vorne nach hinten zu verarbeiten. Da ergaenzen sich unsere Programme sehr gut.

[inne]

Das schöne an deiner Lösung ist, dass Du nicht wissen musst, wann der String endet. Es wird am Dezimaltrenner erkannt. Ersteres dachte ich mir schon und meinte ich mit Stream vs. Matrix. Das finde ich gelungen!

[inne]

Hallo,

auf Intagram habe ich von der Kaprekar-Konstante gehört, und fand es eine schöne Aufgabe ein Skript zu schreiben, das die Behauptung, es gäbe die Kaprekar-Konstante für alle vierstelligen Zahlen prüft. Darum wollte ich diese Aufgabe hier vorstellen. Interessant ist das vor allem, wenn man vorher die Kaprekar-Konstanten noch nicht kannte.

Behauptung ist also, dass die Kaprekar-Konstante für alle vierstelligen Zahlen 6174 ist.
Um die Kaprekar-Konstante zu berechnen nimmt man eine vierstellige Zahl z.B. 2134 und sortiert die einzelnen Ziffern einmal absteigend, so dass daraus die größt mögliche Zahl entsteht und einmal aufsteigend so dass daraus die kleinstmögliche Zahl entsteht.
Also hier 4321 und 1234.
Aus diesen Zahlen errechnet man die Differenz, in dem man die keinere Zahl von der größeren Zahl subtrahiert.
4321-1234=3087
Ist das Ergebnis wie hier nicht 6174, nimmt man die Differenz/Das Erbeniss, füllt ggf. führenen Nullen an, damit wieder vier Stellen vorhanden sind und berechnet mit dieser Zahl nochmal neu.
Das macht man solange, bis das Ergebnis 6174 ist.
PS: Es gibt Ausnahmen, wo diese Behauptung nicht zutrifft.

Für dreistellige Zahlen ist die Kaprekar-Konstante übrigens 495 und für zweistellige Zahlen gibt es eine Kaprekar-Konstanten-Folge die immer 81, 63, 27, 45, 9, 81, ... ist. Einstellige Zahlen zeigen nochmal warum es Ausnahmen gibt, wo diese Behauptung nicht zutrifft.

Hier ist der Wikipedia Auszug dazu:
https://de.wikipedia.org/wiki/Kaprekar-Konstante

[Phineas]

Ist das hier denn immer noch ein Scripting Contest oder macht ihr mit C weiter?

[Meillo]

Ist das hier denn immer noch ein Scripting Contest oder macht ihr mit C weiter?

Wir haben das nie so eng gesehen. Es ist freie Programmiersprachenwahl.

Btw: Den TCC kann man auch in die Shebangzeile schreiben und damit C-Code wie ein Script on the fly compilieren und ausfuehren lassen. Das ist dann auch nicht anders als es beispielsweise Python macht.
https://en.wikipedia.org/wiki/Tiny_C_Compiler

[inne]

Ist das hier denn immer noch ein Scripting Contest oder macht ihr mit C weiter?

Ist das so zu verstehen, dass Du Phineas dann zum Sonntag auch ein Lösung bereit hältst?

[Meillo]

Ist das hier denn immer noch ein Scripting Contest oder macht ihr mit C weiter?

Ist das so zu verstehen, dass Du Phineas dann zum Sonntag auch ein Lösung bereit hältst?

[Phineas]

Möglich, dass ich eine Lösung finde und poste.

Mit Skript gegen C anzutreten wirkt auf mich, wie Kettcar gegen M8.

[GregorS]

... Kettcar gegen M8.

Wie kann ein Kettcar gegen ein metrisches Gewinde antreten?

[Phineas]

Ich meine eher dieses Kerlchen:
https://de.wikipedia.org/wiki/BMW_G15

[GregorS]

Ich meine eher dieses Kerlchen:
https://de.wikipedia.org/wiki/BMW_G15

Ach so.

Ja, das ist ein hübsches Auto.

[Meillo]

Mit Skript gegen C anzutreten wirkt auf mich, wie Kettcar gegen M8.

Sicher! Ein kleines, elegantes Script gegen ein fettes, schweres C-Programm. -- Es kommt immer auf die Betrachtungsweise an!

Diesbezueglich soll hier aber nicht gewertet werden. Es geht um den Spass an der Umsetzung, voellig egal in welcher Programmiersprache. Wenn du Lust hast, etwas zu programmieren, dann waere es toll, wenn du das tust.

[MSfree]

Ein kleines, elegantes Script gegen ein fettes, schweres C-Programm.

Das "kleine, elegantes Script" wird aber von einem fetten, schweren Interpreter ausgeführt, der für sich betrachtet die Schwere eines eigenständigen C-Programmes deutlich übertrifft.

[Meillo]

Ein kleines, elegantes Script gegen ein fettes, schweres C-Programm.

Das "kleine, elegantes Script" wird aber von einem fetten, schweren Interpreter ausgeführt, der für sich betrachtet die Schwere eines eigenständigen C-Programmes deutlich übertrifft.

Und nichts davon uebertrifft die Schwere von Visual Studio Code, in dem man das Script oder Programm programmiert ... so dass es am Ende unerheblich ist, ob es nun ein Interpreter oder Compiler war.

... es waere schon mal eine interessante Frage, wie fett die ganzen verwendeten Programme jeweils sind, im Verhaeltnis zum Script/Programm, das man eigentlich schreibt. Also einfach mal, um ein Gefuehl dafuer zu bekommen. Wenn man keine IDE einsetzt, dann wir der Compiler/Interpreter sicherlich immer die groesste Komponente sein. IDEs werden diese aber vermutlich uebertreffen. Wobei insgesamt die fetteste Komponente wohl der Browser ist, inklusive der Massen an JS-Code auf Stackoverflow, wenn man sich Codeschnipsel zusammensucht.

[inne]

Möglich, dass ich eine Lösung finde und poste.

Mit Skript gegen C anzutreten wirkt auf mich, wie Kettcar gegen M8.

Hallo Phineas, hallo all,

bei dieser Aufgabe würde ich auch keinen Gewinner ermitteln wollen.
Viel mehr wird es interessant sein, zu sehen wie die Aufgabe Verstanden wurde und wie umgestzt wurde. Ich könnte mir vorstellen, dass es viele verschiedene Ansätze geben wird? Aber vlt. irre ich damit auch. Aber meine Lösung sucht z.B. auch^^ Damit habe ich nun beides in einem.

[tobo]

Wer sich an innes Vorschlag zu Kaprekar-Konstanten versucht und auch die Zyklen im höheren Raum beachten will, der sollte sich nicht an der deutschen Wikipedia-Seite orientieren (phasenverschoben), sondern hier:
https://kaprekar.sourceforge.net/output/sample.php

[inne]

Und wer verlängern möchte weil ihm noch andere Ideen eingefallen sind, dann wäre es für mich OK, das auch auf nächsten So.den 13. zu verschieben. Etwas knapp ist die Zeit vlt. schon.
Aber für mich wäre Morgen 18 Uhr OK, wenn keiner was sagt.

@Phineas, Ich habe Perl genommen, das hätte ich auch im anderen Post schon sagen sollen! Das sollte fair sein

[tobo]

Aber für mich wäre Morgen 18 Uhr OK, wenn keiner was sagt.

So wahnsinnig groß war der öffentliche Widerspruch offensichtlich nicht - was genau hindert dich an der Umsetzung?

[inne]

Guten Mogren,
so richtig zugesagt hatte Phineas nicht, und so wie es aussieht wäre ich auch einziger gewesen? Und mir ging es gerade darum Lösungen anderer zu sehen. Also wollte ich nicht als erster/einziger hier was zeigen, so wie Phineas nicht mit C wollte.

PS: Auf Github muss man nur aufpassen, weil es einmal die Kaprekar-Konstate und einmal die Kaprekar-Zahl gibt.

[tegula]

Mein Lösungsvorschlag in R. --> Script: 41816. Ausgabe: 41817.

EDIT (07.11.2022 um 17:37 Uhr): NoPaste-Links aktualisiert.

[inne]

Mit R hatte ich noch nichts zu tun, es wird etwas dauern das auzuprobieren!
Deine Ausgage sagt:

Information
Du hast keinen Eintrag ausgewählt.
Zurück zum NoPaste

Es scheint etwas falsch verlinkt zu sein?

Hier dann mal meine Lösung (Ob die 100% korrekt ist, vermag ich nicht zu sagen):

Code: Alles auswählen

#!/usr/bin/env perl


#our @numbers=(0..9);
#our @kaprekar_const=0;
# ---
# Output ist
# perl kaprekar-const.pl
# -> 0


#our @numbers=(10..99);
#our @kaprekar_const=(9,27,45,63,81);
# ---
# Output ist
# perl kaprekar-const.pl
# -> 9
# -> 27
# -> 45
# -> 63
# -> 81


#our @numbers=(100..999);
#our @kaprekar_const=495;
# ---
# Output ist
# perl kaprekar-const.pl
# -> 495


our @numbers=(1000..9999);
our @kaprekar_const=6174;
# ---
# Output ist
# perl kaprekar-const.pl
# -> 6174


our $v = 0; # verbose (boolean)
our $length=length($numbers[0]);
our $max_steps=7;

use feature 'say';

sub kaprekar_const {
	my ($z, $k) = @_;
	my $step;

	warn "number $z (kaprekar $k):" if ($v);

	while ($step++ < $max_steps) {

		# mit führenden Nullen auffüllen
		while (length($z) < $length) {
			$z = '0' . $z;
		}

		my $minuend    = join('',reverse(sort(split('',$z))));
		my $subtrahend = join('',        sort(split('',$z)));

		my $differenz  = $minuend - $subtrahend;

		warn "step $step: $minuend - $subtrahend = $differenz" if ($v);

		if ($differenz == $k) {
			return $step;
		}

		if ($differenz == 0) {
			return 0;
		}

		$z = $differenz;

	}

	return -1;
}

my $ret = 1;
for my $k (@kaprekar_const) {

	my $found = 1;
	for my $z (@numbers) {
		if (kaprekar_const($z, $k) == -1) {
			$found = 0;
			last;
		}
	}

	if ($found) {
		say "-> $k";
		$ret = 0;
	}

}

exit $ret;

[inne]

Mein Lösungsvorschlag in R. --> Script: 41814. Ausgabe: 41815.

Anmerkung: Das Package summarytools wird nicht benötigt. Hab vergessen den entsprechenden library-Befehl zu löschen, bevor ich Script und Ausgabe ins NoPaste hochgeladen habe.

Nun hast Du es zurückgezogen? Wollte es gerade herunterladen...

[tegula]

Sorry . Hatte mich dann doch dazu entschieden, meine Uploads nochmal zu aktualisieren. Das sind die neuen NoPaste-Links :

Mein Lösungsvorschlag in R. --> Script: 41816. Ausgabe: 41817.

EDIT (07.11.2022 um 17:37 Uhr): NoPaste-Links aktualisiert.

[inne]

Also funktionieren tut es:

Code: Alles auswählen

── Attaching packages ─────────────────────────────────────── tidyverse 1.3.2 ──
✔ ggplot2 3.3.6      ✔ purrr   0.3.5 
✔ tibble  3.1.8      ✔ dplyr   1.0.10
✔ tidyr   1.2.1      ✔ stringr 1.4.1 
✔ readr   2.1.2      ✔ forcats 0.5.2 
── Conflicts ────────────────────────────────────────── tidyverse_conflicts() ──
✖ dplyr::filter() masks stats::filter()
✖ dplyr::lag()    masks stats::lag()

Attache Paket: ‘magrittr’

Das folgende Objekt ist maskiert ‘package:purrr’:

    set_names

Das folgende Objekt ist maskiert ‘package:tidyr’:

    extract

   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
   6174    6174    6174    6174    6174    6174 
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
      0       0       0       0       0       0 
 

Kann man sich das auch grafisch anzeigen lassen? Und wäre es in R einfach auch Konstanten-Reihen zu erkennen? Ich will da immer zwei Arrays übereinander legen und abgleichen, habe das aber noch nicht in Code formuliert bekommen.