Sie müssen 2 Zeichenfolgen eingeben und die Summe dieser beiden Zeichenfolgen ausgeben, ohne sie in int zu konvertieren oder einen numerischen Datentyp zu verwenden.

Ex.

string one = "123";
string two = "456";    
string sum = "579";

Angenommen, die Zeichenfolgen sind nicht größer als 10 Stellen.

Dies ist Code Golf und die kürzeste Antwort in Zeichen gewinnt. Eine Bearbeitung der Antwort in C # bringt mich zum Lächeln :).

Bearbeiten: Die Konvertierung in int kann als etwas in dieser Art definiert werden

Int.TryParse, (int), Convert.ToIntEtc

80836 Assembly ( 57 53 Byte)

53 55 89 E5 8B 4D 0C 8B 55 10 B0 0A 30 DB 88 CF 00 C1 00 C2 49 4A 8A 01 8A 22 00 E0 00 D8 2C 30 30 DB 3C 39 7E 04 B3 01 2C 0A 88 01 88 22 38 CF 75 E2 5D 5B C3

Dies addiert Ziffer für Ziffer von rechts nach links, ohne ASCII-Ziffern '0'-'9'in Ganzzahlen umzuwandeln 0-9und nach Bedarf zu übertragen. Der Bytecode ist der Code für eine Funktion, die in C aufgerufen werden kann (siehe unten).

Der obige Bytecode wurde von Hand aus der folgenden Baugruppe (NASM-Stil, kommentiert) geschrieben:

; save ebx, ebp
push ebx        ; 53
push ebp        ; 55
; copy esp
mov ebp, esp    ; 8B EC
; load arguments
mov ecx, [ebp+0x0C] ; 8B 4D 0C
mov edx, [ebp+0x10] ; 8B 55 10
; initialize stuff
mov al, 10      ; B0 0A
xor bl, bl      ; 30 DB
mov bh, cl      ; 88 CF
; send edx, ecx to end of string
add cl, al     ; 00 C1
add dl, al     ; 00 C2

; decrement everything
dec ecx         ; 49
dec edx         ; 4A

; get rightmost unprocessed digit of each number
mov al, [ecx]   ; 8A 01
mov ah, [edx]   ; 8A 22

; add two ascii digits
add al, ah      ; 00 E0
; add carry if needed
add al, bl      ; 00 D8
; subtract 0x30 ('0') to get the resulting ascii digit
sub al, 0x30    ; 2C 30

; set bl to 0
xor bl, bl      ; 30 DB

; if greater than '9': must carry over to next place
cmp al, 0x39    ; 3C 39
jle $+6         ; 7E 04
; set bl to 1 if carrying over
mov bl, 1       ; B3 01
; subtract 10 from ascii digit if carrying over
sub al, 0x0A    ; 2C 0A

mov [ecx], al   ; 88 01
mov [edx], ah   ; 88 22


; check if loop has ended
cmp bh, cl      ; 38 CF
jne $-28        ; 75 E2

; restore ebx, ebp
pop ebp         ; 5D
pop ebx         ; 5B
; return
ret             ; C3

So versuchen Sie dies in C (gcc, Linux, Intel-Prozessor):

#include <stdio.h>
#include <string.h>
#include <sys/mman.h>

int main(){
    // bytecode from earlier
    char code[] = {
        0x53, 0x55, 0x8B, 0xEC, 0x8B, 0x4D, 0x0C, 0x8B, 
        0x55, 0x10, 0x31, 0xC0, 0xB0, 0x09, 0x30, 0xDB, 
        0x01, 0xC1, 0x01, 0xC2, 0x40, 0x50, 0x8A, 0x01,
        0x8A, 0x22, 0x00, 0xE0, 0x00, 0xD8, 0x2C, 0x30,
        0x30, 0xDB, 0x3C, 0x39, 0x7E, 0x04, 0xB3, 0x01,
        0x2C, 0x0A, 0x88, 0x01, 0x88, 0x22, 0x58, 0x48,
        0x49, 0x4A, 0x85, 0xC0, 0x75, 0xDF, 0x5D, 0x5B,
        0xC3,
    };
    // allocate executable memory to a function pointer called 'add'
    void __attribute__( (__cdecl__) ) (*add)(char*,char*) = mmap(0,sizeof code,PROT_WRITE|PROT_EXEC,MAP_ANON|MAP_PRIVATE,-1,0);
    memcpy(add, code, sizeof code);

    // test inputs
    char number1[] = "0878295272", number2[] = "8184206821";

    puts(number1);
    puts(number2);

    // call the bytecode as a c function
    add(number1, number2);

    // output is in the first argument
    puts(number1);

    // release allocated memory
    munmap(add, sizeof code);

    return 0;
}

Ruby, 109 71

Käsig. Wenn Sie Mohammad nicht auf den Berg bringen können ...

j=$*
r=n=d=0
(d+=x=j.count{|v|n.to_s==v}
r+=x*n
n+=1)until d>1
p r.to_s

Algorithmus:

1. Vergleichen Sie die Zeichenfolgendarstellung eines Int mit Eingabe 1 und Eingabe 2.
2. Fügen Sie dieses int zum Ergebnis pro Match hinzu.
3. Inkrementieren und wiederholen, bis Sie es zweimal getan haben.
4. Erbrechen Sie sich

Änderungsprotokoll

71 kürzer als ein Array.

85 Methodendeklaration entfernt und Aufrufe an konsolidiert n.to_s

92 einige Tipps angewendet

101 Speichern Sie ein Zeichen

102 Verwenden Sie x zum Inkrementieren

109 anfängliches Festschreiben

sed, 359 Bytes (ohne die ausgefallene Formatierung)

Ich bin mir immer noch nicht sicher, ob dies ein Dup von Add ohne Addition ist (oder einer der 4 grundlegenden arithmetischen Operatoren) . Lassen Sie mich in der Zwischenzeit meine Antwort auf diese Frage kreuzen. Es wird kein Golf gewinnen, aber es ist ein Anfang, und ich denke, es erfüllt leicht die Spezifikation:

                       s/([^ ]+) ([^ ]+)/\1:0::\2:/
                       :d /^([^:]+):\1::([^:]+):/tx
                       s/(:[^:]*)9([_:])/\1_\2/g;td
s/(:[^:]*)8(_*:)/\19\2/g;s/(:[^:]*)7(_*:)/\18\2/g;s/(:[^:]*)6(_*:)/\17\2/g
s/(:[^:]*)5(_*:)/\16\2/g;s/(:[^:]*)4(_*:)/\15\2/g;s/(:[^:]*)3(_*:)/\14\2/g
s/(:[^:]*)2(_*:)/\13\2/g;s/(:[^:]*)1(_*:)/\12\2/g;s/(:[^:]*)0(_*:)/\11\2/g
                       s/:(_+:)/:1\1/g; y/_/0/; # #
                       bd;  :x  s/.*::([^:]+):/\1/;
                       # # # # # # #  # # # # # # #

Die Eingabe erfolgt von STDIN in der Form "x y". Das wird zuerst in "x: 0 :: y:" transformiert. Dann erhöhen wir alle Zahlen, die nach ":" stehen, bis wir "x: x :: :( x + y):" erhalten. Dann kehren wir endlich zurück (x + y).

Ausgabe

$ printf "%s\n" "0 0" "0 1" "1 0" "9 999" "999 9" "12345 67890" "123 1000000000000000000000"  | sed -rf add.sed
0
1
1
1008
1008
80235
1000000000000000000123
$

Beachten Sie, dass dies nur für die natürlichen Zahlen funktioniert. (Zumindest theoretisch) funktioniert es jedoch für beliebig große ganze Zahlen. Da wir x-Inkrementierungsoperationen für y ausführen, kann die Reihenfolge einen großen Unterschied für die Geschwindigkeit bedeuten: x <y ist schneller als x> y.

Ruby - 485 432 265

Dies scheint eher im Sinne dessen zu sein, wonach Sie in der Frage gesucht haben.

Es löst im Grunde das Problem, wie ein Mensch es auf Papier tun würde - indem es alle Ergebnisse der einstelligen Addition "auswendig lernt", jede Spalte hinzufügt und versteht, wie man bei Bedarf "die eine trägt".

Dies verwendet auch einen "numerischen Datentyp" (Variable i), der durch die Frage verboten ist, jedoch nur für die Zeichenfolgenindizierung. Ich werde versuchen, dies zu entfernen und meine Antwort zu bearbeiten.

def s p
(y=(?0..?9).to_a).product(y).map{|x|/#{x.join}/}.zip((?0..'18').to_a.each_cons(10).to_a.flatten).each{|k,v|return v if k=~p.sort.join}
end
a,b=$*.map{|n|n.rjust(10,?0).reverse}
r=?0
c=''
(0..9).each{|i|d=s [a[i],b[i]]
c=s([d[-1],r])+c
r=d[-2]||?0}
puts r+c

Etwas ungolf:

def s p
  y = (?0..?9).to_a
  y.product(y).map{ |x|
    /#{x.join}/
  }.zip(
    (?0..'18').to_a.each_cons(10).to_a.flatten
  ).each{ |k,v|
    return v if k =~ p.sort.join
  }
end

a,b=$*.map{ |n| n.rjust(10,?0).reverse }

r = ?0
c = ''

(0..9).each { |i|
  d = s [ a[i], b[i] ]
  c = s([ d[-1], r ]) + c
  r = d[-2] || '0'
}

puts r+c

BEARBEITEN: Verwenden Sie einige Ideen aus den Kommentaren, um die "gespeicherte" Zuordnungstabelle zu generieren, anstatt sie nur fest zu codieren.

CJam, 95 92 80 72 70 44 Zeichen

"Ǻᨌ⹝瀶噄頼୅籌◳ॶ騥箄덮庸匕帯標ឭ⹞➻䗧㩱砡࣍㤬醻孹꽬"2G#b127b:c~

was übersetzt bedeutet

lW%'0A*+S/zW%{{A,__m*{_1b\saa*~}%\{_saa*~}%+\aa/,(s_,({(@+\}*}%_Wf<s}g

Dies kann definitiv viel Golf gespielt werden. Ich weiß wirklich nicht, ob mein Ansatz optimal ist oder noch nicht.

UPDATE - Inline die Summenmatrixerstellung zum Speichern von Bytes. Aus diesem Grund läuft das Programm jetzt zehnmal langsamer, aber immer noch eine konstante Zeit für jede Art von Eingabe.

Probieren Sie es hier online aus

Liest die Zeile mit zwei Zahlen aus STDIN als Zeichenfolge und gibt sie als Zeichenarray aus, das selbst eine Zeichenfolge ist.

Beispielsweise:

123 4567

Die Ausgabe enthält vorhergehende 0. Lassen Sie mich wissen, ob dies ein Problem ist.

C # - 128 108 104

Vielen Dank an Compass, BMac und Shawn für die Verbesserungsvorschläge.

Erster Versuch bei Code Golf, und die Verwendung von C # scheint hier ein Handicap zu sein ...

Mit können .Compute()Sie die Zeichenfolgenwerte verwenden und direkt summieren. Als Bonus funktioniert dies für andere Betreiber außer nur "+".

Golf:

static void t(string a,string b){System.Console.Write(new System.Data.DataTable().Compute(a+"+"+b,""));}

Ungolfed:

static void t(string a, string b)
{
    System.Console.Write(new System.Data.DataTable().Compute(a+"+"+b,""));
}

Wenn t("123","456");Sie anrufen, erhalten Sie 579.

GNU sed, 266 Bytes

Verwendet einen anderen Ansatz als die Lösung von DigitalTrauma. Infolgedessen ist dieser mit O (m + n) noch schlechter . Konvertieren Sie beide Operanden in unär, verketten Sie, konvertieren Sie zurück in dezimal (alle verwenden natürlich Regex - sed hat nicht das Konzept einer Ganzzahl).

Als Bonus fasst dieses Programm alle natürlichen Ganzzahlen zusammen, die auf stdin (in der ersten Zeile) angegeben sind, was bedeutet, dass Sie nichts, eine oder zehn Zahlen eingeben können und es trotzdem das Richtige tut.

Die Idee hinter diesem Code ist vage von einer alten PPCG-Sed-Vorlage von mir inspiriert, obwohl ich mich nicht erinnere, für welche Frage es eine Antwort ist.

Hier ist es "hübsch" für Ihre "Bequemlichkeit" gedruckt, eine andere Idee von DigitalTrauma auszuleihen. : D.

                s/9/x8/g;
                s/8/x7/g;
                s/7/x6/g;
                s/6/x5/g;
                s/5/x4/g;
                s/4/x3/g;
  s/3/x2/g;s/2/x1/g;s/1/x0/g;s/0\b//g;;
  :l;s/x0/0xxxxxxxxxx/;/x0/bl;s/[^x]//g
  s/^$/0/;:m;s/x{10}/!/g;s/!\b/&0/;;;;;
  s/0x/1/;s/1x/2/;s/2x/3/;s/3x/4/;;;;;;
  s/4x/5/;s/5x/6/;s/6x/7/;s/7x/8/;;;;;;
                s/8x/9/;;
                s/!/x/g;;
                /x{10}/bm
                /x/!q;;;;
                s/^/0/;bm
                #sum.sed#

(Um die 266-Byte-Version zu erhalten, entfernen Sie nachfolgende Semikolons, führende Leerzeichen und den letzten Kommentar, vorzugsweise mit sed.)

Einige Tests von DigitalTrauma ausleihen:

% printf "%s\n" "0 0" "0 1" "1 0" "9 999" "999 9" "12345 6789" "123 100" | while read l; do sed -rf /tmp/sum.sed <<<"$l"; done 
0
1
1
1008
1008
19134
223

Ich habe die wirklich großen Tests wegen der schrecklichen Raumeffizienz ein wenig optimiert. Aufgrund der Verwendung wird qnur die erste Zeile verarbeitet, daher die whileSchleife im Test.

Java 6 (181 Zeichen)

Nicht zu übertreffen durch das Handicap C # , Java in seiner ganzen Pracht. So viel Boilerplate! Die Verwendung besteht darin, die Argumente durch ein Leerzeichen getrennt bereitzustellen, d. H.123 456

import javax.script.*;class T {public static void main(String[] a) throws Exception {System.out.print(new ScriptEngineManager().getEngineByName("JavaScript").eval(a[0]+"+"+a[1]));}}

Ungolfed:

import javax.script.*;

class T {
    public static void main(String[] a) throws Exception {
        System.out.print(new ScriptEngineManager()
                .getEngineByName("JavaScript").eval(a[0] + "+" + a[1]));
    }
}

Durch die Verwendung der in verfügbaren JavaScript-Engine javaxkönnen wir eine andere Sprache für uns arbeiten lassen und die Regeln befolgen, keine numerischen Typen in der Muttersprache zu verwenden oder zu konvertieren.

Begründung für die Verwendung eval

Wir haben die Werte nicht in int konvertiert, damit JavaScript ausgewertet werden kann. Wir haben einen String erstellt, "123+456"der keine Zahl ist. JS Engine verarbeitet die Formel und wertet den String als Zahlenliterale aus, bei denen es sich nicht um numerische Datentypen handelt. Java kitschige Logik! Abgesehen davon funktioniert dies auch für doubleMathematik.

APL (61)

Ich denke, das fällt unter die Regeln.

{⎕D[1+{∨/T←9<Z←0,⍵:∇T↓⍨~×⊃T←(1⌽T)+Z-10×T⋄⍵}+⌿⌽↑⌽¨¯1+⎕D∘⍳¨⍺⍵]}

Dies ist eine Funktion, die zwei Zeichenfolgenargumente akzeptiert und eine Zeichenfolge zurückgibt:

      '123'{⎕D[1+{∨/T←9<Z←0,⍵:∇T↓⍨~×⊃T←(1⌽T)+Z-10×T⋄⍵}+⌿⌽↑⌽¨¯1+⎕D∘⍳¨⍺⍵]}'456'
579
      ⍝ show dimensions (if it was a number, this would give the empty list)
      ⍴'123'{⎕D[1+{∨/T←9<Z←0,⍵:∇T↓⍨~×⊃T←(1⌽T)+Z-10×T⋄⍵}+⌿⌽↑⌽¨¯1+⎕D∘⍳¨⍺⍵]}'456'
3

Es ist auch ziemlich schnell, es addiert die Zahl, die von 999999 9s gebildet wird , in einem Augenblick zu sich selbst.

Es findet den Index jedes Zeichens in ⎕D(dies ist die Zeichenfolge '0123456789'), fügt dann die Grundschule für jeden Index separat hinzu, trägt sie nach Bedarf und sucht dann nach den resultierenden Ziffern in ⎕D. (Ich denke, die ⎕DSuche fällt unter die Regeln, es geht im Grunde nur 'x'-48).

Erläuterung:

• ⎕D∘⍳¨⍺⍵: Schlagen Sie die Indizes ⎕Dfür jedes Zeichen in beiden Zeichenfolgen nach.
• ¯1+: subtrahieren 1von jedem, da die Arrays standardmäßig 1-basiert sind.
• ⌽↑⌽¨: Beides umkehren, in eine Matrix verwandeln (leere Quadrate mit Nullen füllen), dann die Matrix umkehren.
• +⌿: Summiere die Spalten der Matrix
• {... }: übertragen:
  • ∨/T←9<Z←0,⍵: Fügen Sie 0vor der Liste ein zusätzliches hinzu . Finden Sie heraus, welche 'Ziffern' höher als 9 sind, und speichern Sie diese in T. Wenn irgendwelche Ziffern höher als 10 waren:
    • Z-10×T: 10von jeder Position subtrahieren , die höher als 10 ist,
    • T←(1⌽T)+: Fügen Sie 1zu jeder Position neben jeder Position, die höher als 10 war, hinzu und speichern Sie in T.
    • T↓⍨~×⊃T: Wenn Tmit einer Null beginnt, entfernen Sie diese,
    • ∇: Wenden Sie die Übertragsfunktion auf das Ergebnis an.
  • ⋄⍵: Andernfalls geben Sie den Wert unverändert zurück
• 1+: Fügen Sie jeder Position eine hinzu (da das Array 1-indiziert ist)
• ⎕D[... ]: Verwenden Sie das Ergebnis als Index für ⎕D.

Perl - 136 119 115 Bytes

Ich lerne Perl, das schien mir eine gute Übung zu sein. Tipps sind willkommen!

Cheesy Antwort, um das aus dem Weg zu räumen:

print$ARGV[0]+$ARGV[1]; #Adding strings

Aktuelle Antwort:

($x,$y)=@ARGV;while($x.$y.$s){$s-=48-ord$&if$x=~s/.$//;$s-=48-ord$&if$y=~s/.$//;$r=chr($s%10+48).$r;$s=$s>9;}print$r;

Unkomprimiert:

($x,$y)=@ARGV;
while($x.$y.$s){
$s-=48-ord$&if$x=~s/.$//;
$s-=48-ord$&if$y=~s/.$//;
$r=chr($s%10+48).$r;
$s=$s>9;
}
print$r;

Java 7, Punktzahl = 252

Verwendet keine Ganzzahlen, Longs, Bytes, Shorts, Doubles, Floats oder integrierte Bibliotheksfunktionen zum Hinzufügen. Wickeln Sie sich in einen Klassenkörper und rufen Sie mit an t(String1,String2). Bitte füllen Sie Zeichenfolgen mit Nullen auf, damit sie gleich lang sind.

t("123","234")kehrt zurück "0357".

Golf:

char c,d,e,f,g,k;String t(String a,String b){g++;char[]h=a.toCharArray(),i=b.toCharArray(),j=new char[h.length + 1];for(d=(char)h.length;d>f;)j[--d+1]=(c=(e=(char)(h[d]+i[d]-'0'+c))>'9'?g:f)==g?(char)(e-'\n'):e;j[0]=(char)('0'+c);return new String(j);}

Golfed Erweitert mit Klasse:

public class T{

    public static void main(String[] args){
        System.out.println(new T().t(args[0],args[1]));
    }

    char c,d,e,f,g,k;
    String t(String a,String b){
        g++;
        char[]h=a.toCharArray(),i=b.toCharArray(),j=new char[h.length + 1];
        for(d=(char)h.length;d>f;)
            j[--d+1]=(c=(e=(char)(h[d]+i[d]-'0'+c))>'9'?g:f)==g?(char)(e-'\n'):e;
        j[0]=(char)('0'+c);
        return new String(j);
    }
}

Teilweise Golf erweitert:

public class TrickSum{

    public static void main(String[] args){
        System.out.println(new TrickSum().trickSum(args[0], args[1]));
    }

    char carry, i, aSum,nullChar,oneChar;
    public String trickSum(String a, String b){
        oneChar++;
        char[] number1 = toCharArray(a), number2 = toCharArray(b), sum = new char[number1.length + 1];
        for (i = (char) number1.length; i > nullChar;)
            sum[--i + 1] = (carry = (aSum = (char) (number1[i] + number2[i] - '0' + carry)) > '9' ? oneChar : nullChar) == oneChar ? (char) (aSum - '\n') : aSum;
        sum[0] = (char)('0' + carry);
        return new String(sum);
    }

    char[] toCharArray(String string){
        return string.toCharArray();
    }
}

100% erweitert:

public class TrickSum{

    public static void main(String[] args){
        System.out.println(trickSum(args[0], args[1]));
    }

    public static String trickSum(String a, String b){
        char[] number1 = a.toCharArray();
        char[] number2 = b.toCharArray();
        char[] sum = new char[number1.length + 1];
        char carry = '\u0000';
        for (char i = (char)(number1.length - 1); i != '\uFFFF'; i--){
            char aSum = (char) (number1[i] + number2[i] - '0' + carry);
            carry = aSum > '9' ? '\u0001' : '\u0000';
            aSum = (carry == '\u0001') ? (char) (aSum - '\n') : aSum;
            sum[i + 1] = aSum;
        }
        sum[0] = (char)('0' + carry);
        return new String(sum);
    }
}

Java - 257 Zeichen

Wie jeder weiß, gibt es keine bessere Sprache zum Golfen als Java

    class A{public static void main(String[]s){char[]a=s[0].toCharArray();char[]b=s[1].toCharArray();int c=a.length;int d=b.length;int e=0;String f="";for(int i=0;i<Math.max(c,d);i++){f=f+(((i<c?a[i]-48:0)+(i<d?b[i]-48:0)+e)%10);e/=10;}System.out.println(f);}}

Dies ist eine ungolfed Lösung

public static void main(String[] args) {
        char[] aa = args[0].toCharArray();
        char[] bb = args[1].toCharArray();
        int aal = aa.length;
        int bbl = bb.length;

        int reminder = 0;
        String result ="";
        for(int i=0;i<Math.max(aal,bbl);i++){
            result=result+(((i<aal?aa[i]-48:0)+(i<bbl?bb[i]-48:0)+reminder)%10);
            reminder/=10;
        }
        System.out.println(result);
    }

Haskell - 98 94 Bytes

main=do
 a<-getLine
 b<-getLine
 let c d=last$takeWhile(\e->d/=(show$e-1))[0..]
 print$c a+c b

JavaScript (ES6), 55 66 59 *

 f=x=>{for(i=0;i+[]!=x;i++);return i};f((p=prompt)())+f(p())

* Dies macht einige Annahmen:

• Wir befinden uns in einer ES6 REPL-Umgebung (z. B. FireFox 33.1-Browserkonsole).
• Die Leistung spielt keine Rolle (ernsthaft, '9999999999', '9999999999' brauchten ungefähr 20 Minuten, um zurückzukehren)
• Das Konvertieren von Integer in String ist zulässig
• Die Eingabe wird in den Variablen a und b definiert, z. B.:var a='123',b=321'; Geändert, um Eingaben von der Eingabeaufforderung (+11) zu erhalten.
• Der Eingang hat keine führenden Nullen.

Python 2.7, 196 137 Zeichen

Version 2 (kürzer durch Initialisieren des Wörterbuchs mit Code):

n={}
for i in range(10):n[`i`]=i*' '
def q(a,b):f=lambda x:''.join([10**p*n[s] for p,s in enumerate(reversed(x))]);return len(f(a)+f(b))

Vorherige Version 1 (196 Zeichen):

def q(a,b):n,f={0:'','1':' ','2':'  ','3':'   ','4':4*' ','5':5*' ','6':6*' ','7':7*' ','8':8*' ','9':9*' '}, lambda x:''.join(
    [10**p*n[s] for p,s in enumerate(reversed(x))]);return len(f(a)+f(b))

z.B

>>> print q('123','111')
234

Die Wörterbuchschlüssel sind Zeichenfolgen, die Wörterbuchwerte enthalten nur Zahlenkonstanten, um den Code zu verkürzen, und die Berechnung erfolgt durch Verketten von zwei Zeichenfolgen und Erhalten der resultierenden Länge. Ich hoffe, dass dies als "Nichtkonvertieren in Ints" gilt.

Python-Small-Print-Regel-Cheat-Version

class z(int):0
def s(a,b): return z(a)+z(b)

Hinweis:

>>> type(z('4'))
<class '__main__.z'>

Typ z ist ein benutzerdefinierter Typ, den ich definiere: definitiv kein numerischer Typ nach der vom Fragesteller verwendeten Definition, sondern verhält sich nahe genug an einem numerischen Typ, um unter bestimmten Umständen nützlich zu sein . Verhaltensweisen vom Typ z werden in diesem Codebeispiel nur teilweise implementiert. Wenn der CPython-Interpreter 'int' zum Implementieren von z verwendet , handelt es sich lediglich um ein Implementierungsdetail, das nicht mit dem vorliegenden Problem zusammenhängt.