Problème:

Votre but est d'ajouter deux numéros d'entrée sans utiliser des opérateurs mathématiques suivants: +,-,*,/.

De plus, vous ne pouvez utiliser aucune fonction intégrée conçue pour remplacer ces opérateurs mathématiques.

Notation:

Le plus petit code (en nombre d'octets) gagne.

Mise à jour

La plupart des programmes que j'ai vus concaténent deux tableaux contenant leurs numéros ou créent first numberun caractère, ajoutent des second numbercaractères, puis les comptent tous.

Compteur de matrice le plus court: APL avec 8 caractères, par Tobia

Concaténation de tableau la plus courte: Golfscript avec 4 caractères, par Doorknob

Solution logarithmique la plus courte: TI-89 Basic avec 19 caractères, par Quincunx

Solution d'intégration: Mathematica avec 45 caractères, par Michael Stern

Le plus cool, à mon avis: les opérateurs de bitwise en javascript, par dave

Smalltalk, 21 13

Tous les éléments suivants ne fonctionnent que sur des entiers positifs. Voir l' autre réponse Smalltalk pour un sérieux.

version 1

passer à un grand entier et lui demander son index de bit élevé (mauvais index, ST est basé sur 1, donc j'ai besoin d'un décalage à droite supplémentaire):

(((1<<a)<<b)>>1)highBit

version 2

similaire, et même un peu plus court (en raison des règles de priorité Smalltalk et de l'absence de décalage à droite):

1<<a<<b log:2 

version3

une autre variante du thème "taille de concaténation de collection" à partir de
deux nombres a et b,

((Array new:a),(Array new:b)) size

en utilisant des intervalles comme collection, nous obtenons une version plus conviviale pour la mémoire ;-) en 21 caractères:

((1to:a),(1to:b))size

non recommandé pour les calculs lourds, cependant.

version4

Pour votre amusement, si vous voulez échanger du temps contre de la mémoire, essayez:

Time secondsToRun:[
   Delay waitForSeconds:a.
   Delay waitForSeconds:b.
]

ce qui est généralement assez précis (mais pas de garantie ;-)))

version5

écrire dans un fichier et lui demander sa taille

(
    [
        't' asFilename 
            writingFileDo:[:s |
                a timesRepeat:[ 'x' printOn:s ].
                b timesRepeat:[ 'x' printOn:s ]];
            fileSize 
    ] ensure:[
        't' asFilename delete
    ]
) print

Javascript (25)

while(y)x^=y,y=(y&x^y)<<1

Cela ajoute deux variables x et y, en utilisant uniquement les opérations au niveau des bits, et stocke le résultat dans x.

Cela fonctionne aussi avec les nombres négatifs.

C - 38 octets

main(){return printf("%*c%*c",3,0,4);}

Je triche un peu ici, l'OP dit de ne pas utiliser d' opérateurs mathématiques .

Dans *le printf()format signifie que la largeur de champ utilisée pour imprimer le caractère provient d'un argument de printf(), dans ce cas, 3 et 4. La valeur renvoyée printf()est le nombre de caractères imprimés. Donc, en imprimer une ' 'avec une largeur de champ de 3 et une avec une largeur de champ de 4, donne 3 + 4 caractères au total.

La valeur de retour correspond aux numéros ajoutés à l' printf()appel.

Python - 49 octets

En supposant une entrée par placement dans les variables xet y.

from math import*
print log(log((e**e**x)**e**y))

Cette solution de 61 octets est un programme complet:

from math import*
print log(log((e**e**input())**e**input()))

Étant donné que vous n'avez pas interdit les exponentiations, j'ai dû poster ceci. Lorsque vous simplifiez l'expression à l'aide des propriétés des logarithmes, vous obtenez simplementprint input() + input() .

Cela prend en charge les nombres à la fois négatifs et à virgule flottante.

Remarque: j'ai suivi les conseils de gnibbler et divisé cette réponse en trois. Ceci est la solution Mathematica , ce qui est la solution de base TI-89 .

JavaScript [25 octets]

~eval([1,~x,~y].join(''))

Mathematica, 21 octets

Il existe plusieurs façons de procéder dans Mathematica. Premièrement, utilisez la fonction Accumuler et lancez tout sauf le dernier chiffre de la sortie. Comme avec mon autre solution ci-dessous, je suppose que les nombres entrés sont dans les variables aet b. 21 octets.

Last@Accumulate@{a, b}

Plus amusant, bien que composé de 45 caractères, utilisez les chiffres pour définir une ligne et l'intégrer au-dessous.

Integrate[Fit[{{0, a}, {2, b}}, {x, 1}, x], {x, 0, 2}]

En prime, les deux solutions fonctionnent pour tous les nombres complexes, pas seulement pour les entiers positifs comme cela semble être le cas pour d'autres solutions ici.

GolfScript, 6 4 caractères / octets

Entrez sous la forme de 10, 5(=> 15).

~,+,

le + concaténation est un tableau, pas une addition.

Comment cela fonctionne est-il ,utilisé pour créer un tableau de la longueur que le nombre est ( 0,1,...,n-2,n-1). Ceci est fait pour les deux nombres, puis les tableaux sont concaténés. ,est utilisé à nouveau dans un but différent, pour trouver la longueur du tableau résultant.

Maintenant, voici le truc . J'aime vraiment celui-ci parce qu'il abuse du format d'entrée. On dirait qu'il ne s'agit que de saisir un tableau, mais en réalité, puisque l'entrée est exécutée sous forme de code GolfScript, la première ,est déjà faite pour moi! (L'ancienne version à 6 caractères était ~,\,+,au format d'entrée 10 5, ce qui m'a permis d'éliminer 2 caractères en éliminant le \,(tableau d'échange)).

Ancienne version (12) :

Crée une fonction f.

{n*\n*+,}:f;

La répétition et la concaténation des chaînes *et +sont respectivement des fonctions arithmétiques.

Explication: ncrée une chaîne d'un caractère (une nouvelle ligne). C’est ensuite répété a, puis on fait la même chose b. Les chaînes sont concaténées et sont ensuite ,utilisées pour la longueur de chaîne.

C, 29 27 octets

Utilisation de l'arithmétique de pointeur:

f(x,y)char*x;{return&x[y];}

x est défini comme un pointeur, mais l'appelant doit transmettre un entier.

Un utilisateur anonyme a suggéré ce qui suit - également 27 octets, mais les paramètres sont des entiers:

f(x,y){return&x[(char*)y];}

Brainf * ck, 9 36

,>,[-<+>]

++[->,[->>[>]+[<]<]<]>>>[<[->+<]>>]<

Cela fonctionne sans utiliser l'addition simple; il passe à travers et trace une piste de 1, puis les compte

Remarque: Les +et -ne sont que des incréments simples et rien ne peut être fait dans brainf * ck sans eux. Ils ne sont pas vraiment des additions / soustractions, donc je pense que cela compte toujours.

J (6)

Vous n'avez pas dit que nous ne pouvions pas utiliser la fonction succ:

>:@[&0

Usage:

   9>:@[&0(8)
17

Il ne fait que 9 répétitions de >: sur 8.

L'approche de concaténation de liste fonctionne aussi: #@,&(#&0). Et - je sais que c'est contre les règles - je ne peux pas laisser cette réponse se passer de la solution la plus J-ish: *&.^(multiplication sous exponentiation).

Postscript, 41

Nous définissons une fonction avec une expression de 41 octets de la manière suivante:

/a{0 moveto 0 rmoveto currentpoint pop}def

Ensuite, nous l'appelons par exemple comme:

gs -q -dBATCH -c '/a{0 moveto 0 rmoveto currentpoint pop}def' -c '10 15 a ='

Qui donne

25.0

Il gère facilement les négatifs et les flotteurs, contrairement à la plupart des concurrents :-)

bash, 20 caractères

(seq 10;seq 4)|wc -l

Smalltalk (maintenant sérieusement), 123 118 105 (*)

Désolé de répondre deux fois, mais considérez cela comme une réponse sérieuse, tandis que l'autre ressemblait plus à de l'humour. Ce qui suit est réellement exécuté en ce moment même sur toutes nos machines (en matériel, cependant). Etrange que cela ne vienne à l'esprit de personne d'autre ...

En combinant deux demi-additionneurs et en faisant tous les bits des mots en parallèle, nous obtenons (entrées a, b; sorties en s) une version lisible:

  s := a bitXor: b.            
  c := (a & b)<<1.             

  [c ~= 0] whileTrue:[        
     cn := s & c.
     s := s bitXor: c.
     c := cn<<1.
     c := c & 16rFFFFFFFF.
     s := s & 16rFFFFFFFF.
  ].
  s           

La boucle est destinée à la propagation. Les masques garantissent que les entiers signés sont gérés (sans eux, seuls les nombres non signés sont possibles). Ils définissent également la longueur des mots, ce qui précède s’applique en mode 32 bits. Si vous préférez un ajout de 68 bits, remplacez-le par 16rFFFFFFFFFFFFFFFFF.

version golf (123 caractères) (évite le masque long en le réutilisant dans m):

[:a :b||s c n m|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&m:=16rFFFFFFFF.s:=s&m].s]

(*) En utilisant -1 au lieu de 16rFFFFFFFF, nous pouvons mieux jouer au golf, mais le code ne fonctionne plus pour les nombres de précision arbitraire, mais uniquement pour les smallIntegers de la taille d'un mot machine (la représentation de largeIntegers n'est pas définie dans le standard Ansi):

[:a :b||s c n|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&-1.s:=s&-1].s]

cela ramène la taille du code à 105 caractères.

APL, 8 et 12

Rien de nouveau ici, la version comptant le tableau:

{≢∊⍳¨⍺⍵}

et le journal ○ version du journal:

{⍟⍟(**⍺)**⍵}

Je pensais juste qu'ils avaient l'air cool dans APL!

{≢     }       count
  ∊            all the elements in
   ⍳¨          the (two) sequences of naturals from 1 up to
     ⍺⍵        both arguments

{⍟⍟        }   the double logarithm of
   (**⍺)       the double exponential of ⍺
        *      raised to
         *⍵    the exponential of ⍵

sed, 359 octets (sans la mise en forme sophistiquée)

Désolé pour la réponse tardive, et probablement la réponse la plus longue ici de loin. Mais je voulais voir si cela était possible avec sed:

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

Ceci est similaire à https://codegolf.stackexchange.com/a/38087/11259 , qui incrémente simplement les nombres dans une chaîne. Mais au lieu de cela, il effectue les opérations d’incrémentation dans une boucle.

La saisie 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 suivent les caractères ":", jusqu'à obtenir "x: x: :( (x + y):". Ensuite, nous revenons enfin (x + y).

Sortie

$ 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. Comme nous effectuons des opérations d'incrémentation x sur y, l'ordre peut avoir une grande incidence sur la vitesse: x <y sera plus rapide que x> y.

Dash , 18 octets

time -f%e sleep $@

Requiert le temps GNU 1.7 ou supérieur. La sortie est à STDERR.

Essayez-le en ligne!

Notez que cela ne fonctionnera pas en B ash, car sa commande intégrée diffère de l'heure GNU.

Au prix d'un octet supplémentaire, \timepeut être utilisé à la place de timeforcer Bash à utiliser la commande externe.

Javascript (67)

Il y a probablement beaucoup mieux

a=Array;p=Number;r=prompt;alert(a(p(r())).concat(a(p(r()))).length)

Ruby, 18 caractères

a.times{b=b.next}

Et deux autres variantes verbeuses, 29 caractères

[*1..a].concat([*1..b]).size

Une autre version, 32 caractères

(''.rjust(a)<<''.rjust(b)).size

C # - génération de code à la volée

Oui, il y a en fait une addition ici, mais pas l'opérateur + ni même une fonction-cadre qui ajoute, nous générons plutôt une méthode à la volée qui ajoute.

public static int Add(int i1, int i2)
{
    var dm = new DynamicMethod("add", typeof(int), new[] { typeof(int), typeof(int) });
    var ilg = dm.GetILGenerator();
    ilg.Emit(OpCodes.Ldarg_0);
    ilg.Emit(OpCodes.Ldarg_1);
    ilg.Emit(OpCodes.Add);
    ilg.Emit(OpCodes.Ret);
    var del = (Func<int, int, int>)dm.CreateDelegate(typeof(Func<int, int, int>));
    return del(i1, i2);
}

Ruby 39

f=->a,b{[*1..a].concat([*1..b]).length}

R 36

function(x,y)length(rep(1:2,c(x,y)))

où repconstruit un vecteur de xceux suivis de ydeux.

TI Basic 89 - 19 octets

Exécutez ceci dans votre TI-89 (écran d'accueil ou application de programmation):

ln(ln((e^e^x)^e^y))

Cela utilise les règles de journalisation pour calculer x+y, comme dans cette solution . En prime, cela fonctionne pour les nombres décimaux et entiers. Cela fonctionne pour tous les nombres réels. Si les règles de logarithme sont toujours valables avec des exposants complexes, cela fonctionne également pour les nombres complexes. Cependant, ma calculatrice crache des ordures lorsque j'essaie d'insérer des exposants complexes.

Thanks to Michael Stern for teaching me Mathematica notation.

Mathematica - 21 20 bytes

Log@Log[(E^E^x)^E^y]

Cette approche utilise la même approche que cette solution , mais c'est dans Mathematica qu'il faut la raccourcir. Cela fonctionne pour les nombres négatifs et à virgule flottante ainsi que pour les nombres entiers dans xet y.

La simplification de l'expression à l'aide des règles de consignation génère des résultats x+y, mais cela est valable car elle utilise l'exponentiation et non l'un des 4 opérateurs de base.

C # - arithmétique à cordes

Nous convertissons les deux nombres en chaînes, effectuons l'addition en coupant les chaînes (avec carry et tout, vous savez), puis nous analysons en entier. Testé avec i1, i2 en 0..200, fonctionne à merveille. Trouver une addition dans celui-ci!

public static int Add(int i1, int i2)
{
    var s1 = new string(i1.ToString().Reverse().ToArray());
    var s2 = new string(i2.ToString().Reverse().ToArray());
    var nums = "01234567890123456789";
    var c = '0';
    var ret = new StringBuilder();
    while (s1.Length > 0 || s2.Length > 0 || c != '0')
    {
        var c1 = s1.Length > 0 ? s1[0] : '0';
        var c2 = s2.Length > 0 ? s2[0] : '0';
        var s = nums;
        s = s.Substring(int.Parse(c1.ToString()));
        s = s.Substring(int.Parse(c2.ToString()));
        s = s.Substring(int.Parse(c.ToString()));
        ret.Append(s[0]);
        if (s1.Length > 0)
            s1 = s1.Substring(1);
        if (s2.Length > 0)
            s2 = s2.Substring(1);
        c = s.Length <= 10 ? '1' : '0';
    }
    return int.Parse(new string(ret.ToString().ToCharArray().Reverse().ToArray()));
}

C (79)

void main(){int a,b;scanf("%d%d",&a,&b);printf("%d",printf("%*c%*c",a,0,b,0));}

Python -- 22 characters

len(range(x)+range(y))

APL: 2

1⊥

This converts the numbers from base 1, so (n*1^1)+(m*1^2) which is exactly n+m.

Can be tried on TryApl.org

TI-BASIC, 10

Adds X and Y

ln(ln(e^(e^(X))^e^(Y

K, 2 bytes

#&

Usage example:

  #&7 212
219

Apply the "where" operator (monadic &) to the numbers in an input list (possibly taking liberty with the input format). This will produce a list containing the first number of zeroes followed by the second number of ones:

  &3 2
0 0 0 1 1

Normally this operator is used as a "gather" to produce a list of the indices of the nonzero elements of a boolean list, but the generalized form comes in handy occasionally.

Then simply take the count of that list (monadic #).

If my interpretation of the input requirements is unacceptable, the following slightly longer solution does the same trick:

{#&x,y}

Pyth, 29 bytes

AQW!qG0=k.&GH=HxGH=k.<k1=Gk)H

Try it online!

My first submission here!

This compiles to:

assign('Q',eval_input())     # Q
assign('[G,H]',Q)            #A
while Pnot(equal(G,0)):      #  W!qG0
  assign('k',bitand(G,H))    #       =k.&GH
  assign('H',index(G,H))     #             =HxGH  (index in this case is XOR)
  assign('k',leftshift(k,1)) #                  =k.<k1
  assign('G',k)              #                        =Gk)
imp_print(H)                 #                            H