Vous devez prendre 2 entrées de chaîne et produire la somme de ces deux chaînes sans les convertir en int ou en utilisant un type de données numérique.

ex.

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

Supposons que les chaînes ne dépassent pas 10 chiffres.

C'est le golf de code et la réponse la plus courte dans les victoires de caractères. Une modification de la réponse en C # me fera sourire :).

Edit: la conversion en int peut être définie comme n'importe quoi de cette nature

Int.TryParse, (int), Convert.ToIntEtc.

80836 Assembly ( 57 53 octets)

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

Cela ajoute, chiffre par chiffre, de droite à gauche, sans convertir les chiffres ascii '0'-'9'en nombres entiers 0-9, et reporter si nécessaire. Le bytecode est le code d'une fonction, qui peut être appelée en C (voir ci-dessous).

Le bytecode ci-dessus a été écrit à la main, à partir de l'assemblage suivant (style NASM, commenté):

; 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

Pour essayer ceci en C (gcc, linux, processeur Intel):

#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;
}

Rubis, 109 71

Ringard. Si vous ne pouvez pas amener Mohammad à la montagne ...

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

Algorithme:

1. Comparez la représentation sous forme de chaîne d'un entier à l'entrée 1 et à l'entrée 2.
2. Ajoutez cet entier au résultat par correspondance.
3. Incrémentez et répétez jusqu'à ce que vous l'ayez fait deux fois.
4. Vomissez sur vous-même

Changelog

71 plus court sous forme de tableau.

85 Suppression de la déclaration de méthode et consolidation des appels à n.to_s

92 ont appliqué quelques conseils

101 enregistrer un char

102 utiliser x pour incrémenter

109 commit initial

sed, 359 octets (sans le formatage de fantaisie)

Je ne sais toujours pas s'il s'agit d'un dup d' Add sans addition (ou l'un des 4 opérateurs arithmétiques de base) . En attendant, permettez-moi de poster ma réponse pour cette question. Ça ne va pas gagner de golf, mais c'est un début, et je pense qu'il répond facilement à la spécification:

                       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/;
                       # # # # # # #  # # # # # # #

L'entrée provient de STDIN sous la forme "x y". Cela est d'abord transformé en "x: 0 :: y:". Ensuite, nous incrémentons tous les nombres qui viennent après les caractères ":", jusqu'à ce que nous obtenions "x: x: :( x + y):". Ensuite, nous revenons finalement (x + y).

Production

$ 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
$

Notez que cela ne fonctionne que pour les nombres naturels. Cependant (en théorie du moins), cela fonctionne pour des entiers arbitrairement grands. Parce que nous effectuons x opérations d'incrémentation sur y, la commande peut faire une grande différence dans la vitesse: x <y sera plus rapide que x> y.

Rubis - 485 432 265

Cela semble plus dans l'esprit de ce que vous cherchiez dans la question.

Il résout fondamentalement le problème de la façon dont un humain le ferait sur papier - en «mémorisant» tous les résultats d'addition à un chiffre, en ajoutant chaque colonne et en comprenant comment «porter celui» si nécessaire.

Cela utilise également un "type de données numériques" (variable i), ce qui est interdit par la question, mais ce n'est que pour l'indexation des chaînes. Je vais essayer de supprimer cela et de modifier ma réponse.

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

Assez peu golfé:

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

EDIT: Utilisé quelques idées des commentaires pour générer la table de mappage "mémorisée" au lieu de simplement la coder en dur.

CJam, 95 92 80 72 70 44 caractères

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

ce qui se traduit par

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

Cela peut certainement être beaucoup joué au golf. Je ne sais vraiment pas si mon approche est optimale ou pas encore.

UPDATE - Inline la création de la matrice de somme pour économiser les octets. Pour cette raison, le programme s'exécute maintenant 10 fois plus lentement, mais toujours un temps constant pour tout type d'entrée.

Essayez-le en ligne ici

Lit la ligne contenant deux nombres de STDIN sous forme de chaîne et affiche un tableau de caractères qui est une chaîne elle-même.

Par exemple:

123 4567

La sortie contient le précédent 0. Faites-moi savoir si c'est un problème.

C # - 128 108 104

Merci à Compass, BMac et Shawn d'avoir suggéré des améliorations.

Essayez d'abord sur Code Golf, et l'utilisation de C # semble être un handicap ici ...

En utilisant, .Compute()vous pouvez utiliser les valeurs de chaîne et les additionner directement. En prime, cela fonctionne pour les autres opérateurs en plus du "+".

Golfé:

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

Non golfé:

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

L'appel t("123","456");vous donne 579.

GNU sed, 266 octets

Utilise une approche différente de la solution de DigitalTrauma. En effet, celui-ci fonctionne encore plus mal, en utilisant O (m + n) . Convertir les deux opérandes en unaire, concaténer, reconvertir en décimal (tout en utilisant l'expression régulière bien sûr — sed n'a pas le concept d'un entier).

En bonus, ce programme résume tous les entiers naturels donnés sur stdin (dans la première ligne), ce qui signifie que vous ne pouvez rien lui donner, un ou dix chiffres et qu'il fera la bonne chose malgré tout.

L'idée derrière ce code est vaguement inspirée d'une ancienne soumission de PPCG sed, bien que je ne me souvienne pas pour quelle question c'est une réponse.

La voici, "jolie" - imprimée pour votre "commodité", pour emprunter une autre idée à DigitalTrauma. :RÉ

                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#

(Pour obtenir la version 266 octets, supprimez les points-virgules de fin, les espaces blancs de tête et le commentaire final, de préférence à l'aide de sed.)

Emprunter certains tests de DigitalTrauma:

% 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

J'ai légèrement modifié les très gros tests en raison de la terrible efficacité (in) de l'espace. En raison de l'utilisation de qseulement la première ligne est traitée, d'où la whileboucle dans le test.

Java 6 (181 caractères)

Ne pas être surpassé par le handicap connu sous le nom de C # , Java dans toute sa splendeur. Tant de passe-partout! L'utilisation fournit les arguments séparés par un espace, c'est-à-dire123 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]));}}

Non golfé:

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]));
    }
}

En utilisant le moteur JavaScript disponible en javax, nous pouvons faire en sorte qu'une autre langue fasse le travail pour nous et suivre techniquement les règles de ne pas utiliser de types numériques dans la langue maternelle ou de convertir.

Justification de l'utilisation eval

Nous n'avons pas converti les valeurs en int pour JavaScript en eval. Nous avons créé une chaîne "123+456"qui n'est pas un nombre. JS Engine digère la formule et évalue la chaîne sous forme de littéraux numériques, qui ne sont pas des types de données numériques. Logique de fromage Java! En passant, cela fonctionne également pour les doublemathématiques.

APL (61)

Je pense que cela relève des règles.

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

Il s'agit d'une fonction qui prend deux arguments de chaîne et renvoie une chaîne:

      '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

C'est aussi assez rapide, il ajoute le nombre formé par 999999 9s à lui-même en un instant.

Il trouve l'index de chaque caractère dans ⎕D(qui est la chaîne '0123456789'), puis ajoute des notes d'école sur chaque index séparément, transportant au besoin, puis recherche les chiffres résultants ⎕D. (Je pense que la ⎕Drecherche est conforme aux règles, elle ne fait que le faire 'x'-48).

Explication:

• ⎕D∘⍳¨⍺⍵: recherchez les indices ⎕Dpour chaque caractère dans les deux chaînes.
• ¯1+: soustrayez 1de chacun, car les tableaux sont basés sur 1 par défaut.
• ⌽↑⌽¨: inversez les deux, transformez-vous en matrice (remplissez les carrés vides de zéros), puis inversez la matrice.
• +⌿: somme les colonnes de la matrice
• {... }: report:
  • ∨/T←9<Z←0,⍵: ajoutez un extra 0devant la liste. Découvrez quels «chiffres» sont supérieurs à 9 et stockez-les dans T. Si des chiffres étaient supérieurs à 10:
    • Z-10×T: soustraire 10de chaque position supérieure à 10,
    • T←(1⌽T)+: ajoutez 1à chaque position à côté de chaque position supérieure à 10 et enregistrez-la T.
    • T↓⍨~×⊃T: si Tcommence par un zéro, supprimez-le,
    • ∇: applique la fonction de report au résultat.
  • ⋄⍵: sinon, retourne la valeur inchangée
• 1+: ajoutez un à chaque position (car le tableau est indexé 1)
• ⎕D[... ]: utilisez le résultat comme index dans ⎕D.

Perl - 136 119 115 115 octets

J'apprends Perl, cela semblait être une bonne pratique. Les pourboires sont appréciés!

Réponse ringarde, pour éliminer cela:

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

Réponse réelle:

($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;

Non compressé:

($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, score = 252

N'utilise aucun entier, long, octet, short, double, float ou aucune fonction de bibliothèque intégrée pour l'ajout. Enveloppez dans un corps de classe et appelez avec t(String1,String2). Veuillez remplir les chaînes avec des 0 afin qu'elles aient une longueur égale.

t("123","234")retourne "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 Développé avec classe:

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);
    }
}

Golf partiellement élargi:

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% étendu:

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 caractères

comme tout le monde connaît java, il n'y a pas de meilleur langage pour le golf que 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);}}

c'est une solution non golfée

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 octets

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())

* Cela fait quelques hypothèses:

• Nous sommes dans un environnement ES6 REPL (ex. Console de navigateur FireFox 33.1)
• Les performances n'ont pas d'importance (sérieusement, «9999999999», «9999999999» ont mis environ 20 minutes à revenir)
• La conversion de nombre entier en chaîne est autorisée
• L'entrée est définie dans les variables a et b, ex:var a='123',b=321'; modifié pour obtenir l'entrée de l'invite (+11).
• L'entrée n'a pas de zéros non significatifs.

Python 2.7, 196137 caractères

version 2 (plus courte en initialisant le dictionnaire avec le 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))

Version précédente 1 (196 caractères):

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))

par exemple

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

Les clés du dictionnaire sont des chaînes, les valeurs du dictionnaire incluent uniquement des constantes numériques pour raccourcir le code, et le calcul se fait en concaténant deux chaînes et en obtenant la longueur résultante, donc j'espère que cela compte comme "ne pas les convertir en ints".

Version de tricheur de règles en petit caractères Python

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

Remarque:

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

Le type z est un type personnalisé que je définis comme: certainement pas un type numérique quelle que soit la définition utilisée par le questionneur, mais se comporte suffisamment près d'un type numérique pour être utile dans des circonstances limitées . Les comportements de type z ne sont que partiellement implémentés dans cet exemple de code, et si l'interpréteur CPython utilise 'int' pour implémenter z , il s'agit simplement d'un détail d'implémentation et non lié au problème à résoudre.