Il y a eu de nombreux défis "Do __ without _ _" auparavant, mais j'espère que c'est l'un des plus difficiles.

Le défi

Vous devez écrire un programme qui prend deux nombres naturels (nombres entiers> 0) de STDIN et imprime la somme des deux nombres dans STDOUT. Le défi est que vous devez utiliser aussi peu +et -signes que possible. Vous n'êtes pas autorisé à utiliser des fonctions de somme ou de négation.

Exemples

contribution

123
468

sortie

591

contribution

702
720

sortie

1422

Tie Breaker: Si deux programmes ont le même nombre de caractères +et -, le gagnant est la personne avec moins de caractères / * ( ) = . ,et 0-9.

Non autorisé: langues dans lesquelles les opérateurs standard d'addition / soustraction et d'incrémentation / décrémentation sont des symboles différents +ou -non autorisés. Cela signifie que les espaces blancs de la langue ne sont pas autorisés.

Perl (pas de +/-, pas de bris d'égalité, 29 caractères)

s!!xx!;s!x!$"x<>!eg;say y!!!c

En prime, vous pouvez faire la somme de code plus de deux nombres en ajoutant plus de xs au s!!xx!.

Alternativement, voici deux solutions de 21 caractères avec 1 et 3 disjoncteurs respectivement

say length$"x<>.$"x<>

say log exp(<>)*exp<>

Remarque: Ces solutions utilisent la sayfonction, disponible depuis Perl 5.10.0 avec le -Ecommutateur de ligne de commande ou avec use 5.010. Voir l' historique des modifications de cette réponse pour les versions qui fonctionnent sur les anciennes perls.

Comment fonctionne la solution sans bris d'égalité?

• s!!xx!est un opérateur de remplacement d'expression régulière , opérant par défaut sur la $_variable, qui remplace la chaîne vide par la chaîne xx. (Généralement /utilisé comme séparateur regexp en Perl, mais vraiment presque tout caractère peut être utilisé que j'ai choisi. !Car il est pas départager.) Ceci est juste une façon élégante de préfixer "xx"à $_- ou, depuis $_commence vide (non défini, en fait), c'est vraiment un moyen d'écrire $_ = "xx"sans utiliser le signe égal (et avec un caractère de moins aussi).

• s!x!$"x<>!egest un autre remplacement de l' expression rationnelle, cette fois en remplaçant chaque xdans $_la valeur de l'expression $" x <>. (Le gcommutateur spécifie le remplacement global, espécifie que le remplacement doit être évalué en tant que code Perl au lieu d'être utilisé comme chaîne littérale.) $"Est une variable spéciale dont la valeur par défaut se trouve être un espace unique; l'utiliser au lieu d' " "enregistrer un caractère. (Toute autre variable connue pour avoir une valeur à un caractère, comme $&ou $/, fonctionnerait aussi bien ici, sauf que l'utilisation $/me coûterait un bris d'égalité.)

  L' <> opérateur d'entrée de ligne , dans un contexte scalaire, lit une ligne à partir de l'entrée standard et la renvoie. L' xavant c'est l' opérateur de répétition de chaîne Perl , et c'est vraiment le cœur de cette solution: il retourne son opérande gauche (un seul espace) répété le nombre de fois donné par son opérande droit (la ligne que nous venons de lire en entrée).

• y!!!cest juste une manière obscure d'utiliser (ab) l' opérateur de translittération pour compter les caractères dans une chaîne ( $_par défaut, encore une fois). J'aurais pu juste écrire say length, mais la version obscurcie est plus courte d'un caractère. :)

R (24 caractères)

length(sequence(scan()))

Ce que cela fait:

• scan lit l'entrée de STDIN (ou d'un fichier)
• sequencegénère des séquences entières à partir de 1 et concatène les séquences. Par exemple, les sequence(c(2, 3))résultats dans le vecteur1 2 1 2 3
• length calcule le nombre d'éléments dans le vecteur concaténé

Exemple 1:

> length(sequence(scan()))
1: 123
2: 468
3:
Read 2 items
[1] 591

Exemple 2:

> length(sequence(scan()))
1: 702
2: 720
3:
Read 2 items
[1] 1422

ré

main(){
    int a,b;
    readf("%d %d",&a,&b);
    while(b){a^=b;b=((a^b)&b)<<1;}
    write(a);
}

peu tordu pour la victoire

en prime, le code compilé ne contient pas d'opération d'ajout (ne peut pas parler pour l'appel readf cependant)

Python 2, 43 octets

print len('%s%s'%(input()*'?',input()*'!'))

GolfScript

Pas de +/- ou de bris d'égalité:

# Twiddle some bits to get a few small integers
[]!~abs:two~abs:three!:zero~:minusone;

~[two base minusone%\two base minusone%]zip
zero:c;
{
    # Stack holds [x y] or [x] with implicit y is zero
    # Half adder using x y c: want to end up with sum on stack and carry back in c
    [~c zero]three<zero$
    ~^^\
    $~;:c;;
}%
[~c]minusone%two base

Version beaucoup plus simple avec deux caractères de départage, utilisant la même astuce de concaténation de liste que d'autres personnes utilisent:

~[\]{,~}%,

Je suppose que GolfScript n'est pas disqualifié pour avoir )un opérateur d'incrémentation, car je ne l'utilise pas réellement.

C (32 bits uniquement)

int main(int ac, char *av) {
    scanf("%d\n%d", &ac, &av);
    return printf("%d\n", &av[ac]);
}

L'arithmétique des pointeurs est tout aussi bonne.
Comment correspond-il aux exigences?
* Non +ou -
* Non /, =, ., 0- 9
* Seulement 3 paires de parenthèses, ce qui me semble minime ( dont vous avez besoin main, scanf, printf).
* Un *(l'approche par pointeur l'exige).
* Quatre ,(pourrait sauver un en définissant des variables normales, pas ac,av)

C ++ 0 +/-, 3 bris d'égalité

#include <vector>
#include <iostream>

#define WAX (
#define WANE )
#define SPOT .

int main WAX WANE {
    unsigned x;
    unsigned y;
    std::cin >> x >> y;
    std::vector<int> v WAX x WANE;
    std::vector<int> u WAX y WANE;
    for WAX auto n : u WANE {
        v SPOT push_back WAX n WANE;
    }
    std::cout << v SPOT size WAX WANE;
}

Haskell, 0 + 2

import Monad
main = join $ fmap print $ fmap length $ fmap f $ fmap lines getContents
f x = join $ flip replicate [] `fmap` fmap read x

Cela utilise non +ou des -caractères, et seulement deux =de l'ensemble des caractères de départage, dont l'un est obligatoire pour la liaison main. La somme se fait en concaténant des listes des longueurs appropriées.

EDIT Ceci a été publié AVANT que les règles ne soient modifiées pour interdire sum...

Le langage R: pas d'appels à +ou -... Et 9 personnages de départage!

sum(as.numeric(readLines(n=2)))

Exemple:

> sum(as.numeric(readLines(n=2)))
123
456
[1] 579

le [1] 579 la réponse 579 ( [1]c'est de garder une trace de l'endroit où vous êtes dans le vecteur de résultat car dans R toutes les valeurs sont des vecteurs - dans ce cas de longueur 1)

Notez que R a + opérateurs comme la plupart des langages - il se trouve qu'il en a sumaussi qui résume un tas de vecteurs.

Dans ce cas, readLines retourne un vecteur chaîne de longueur 2. Je le force ensuite à le numérique (double) et le résume ...

Juste pour montrer quelques autres fonctionnalités de R:

> 11:20 # Generate a sequence
 [1] 11 12 13 14 15 16 17 18 19 20

> sum(1:10, 101:110, pi)
[1] 1113.142

Le langage R

Nouvelles règles, nouvelle réponse, même langue. Pas d'appels vers +ou-

MISE À JOUR En utilisant scan, il tombe à 11 caractères de départage (et 27 caractères en tout).

as.numeric(scan())%*%c(1,1)

Original: 13 personnages décisifs!

as.numeric(readLines(n=2)) %*% c(1,1)

Exemple:

> as.numeric(readLines(n=2)) %*% c(1,1)
123
456
     [,1]
[1,]  579

Cette fois, le résultat est obtenu par multiplication matricielle. La réponse est affichée sous forme de matrice 1x1.

Haskell, 0 +/ -, 6 2 briseurs d'égalité ( =)

(n'utilise pas l'astuce de concaténation chaîne / liste)

main = interact f
f x = show $ log $ product $ map exp $ map read $ lines x

Javascript, 56

p=prompt;alert(Array(~~p()).concat(Array(~~p())).length)

Merci à @JiminP sur le ~~ tip! Je vais au moins octets, donc la sauvegarde de 1 octet sur l'invite p =; en vaut toujours la peine. Je comprends votre argument sur les caractères de départage, mais pour être honnête, ne préférez-vous pas les moindres octets :-p

Version, 69

i=parseInt;p=prompt;alert(Array(i(p())).concat(Array(i(p()))).length)

Grâce aux commentaires de @Ilmari et @JiminP, j'ai réduit de 13 octets ma solution d'origine.

À l'origine, 82

i=parseInt;p=prompt;a=Array(i(p()));a.push.apply(a, Array(i(p())));alert(a.length)

C

b[500];i;j;main(){scanf("%d%d",&i,&j);printf("%d\n",sprintf(b,"%*s%*s",i,"",j,""));

APL (pas de +/-, pas de bris d'égalité, 8 ou 10 caractères)

Cette entrée est similaire aux autres qui concaténent les séquences générées à partir de l'entrée et trouvent la longueur ... mais c'est en APL, ce qui peut sembler déroutant même pour un petit problème comme celui-ci. J'ai utilisé Dyalog APL , qui offre une licence éducative gratuite.

Code:

⍴⊃⍪⌿⍳¨⎕⎕

De droite à gauche:

• Chaque guillemet ( ⎕ ) demande l'entrée de l'utilisateur et l'évalue.
• Chaque opérateur ( ¨) applique la fonction de générateur d'index ( ⍳ ) à chacun des éléments du tableau à sa droite.
• Cela aplatit le tableau de tableaux résultant en un seul tableau. Le tableau d'entrée est réduit à une liste plate par l'opérateur de réduction ( /), qui replie le tableau à l'aide de la fonction de concaténation ( ,). Pour relever ce défi, l'opérateur de réduction unidimensionnel ( ⌿) est utilisé, ainsi que l'opérateur de concaténation le long du premier axe (⍪ ).
• Grâce à l'utilisation de l'opérateur de réduction, le réseau est enfermé , ce qui revient à le placer dans le sac; tout ce que nous voyons à l'extérieur est un sac, pas son contenu. L'opérateur de divulgation (⊃ ) nous donne le contenu du tableau joint (le sac).
• Enfin, la fonction shape-of ( ⍴) nous donne les longueurs des dimensions d'un tableau. Dans ce cas, nous avons un tableau unidimensionnel, nous obtenons donc le nombre d'éléments dans le tableau, ce qui est notre résultat.

Si nous devons afficher explicitement le résultat, nous pouvons le faire comme ceci:

⎕←⍴⊃⍪⌿⍳¨⎕⎕

Code Python comparable, avec les symboles APL correspondants ci-dessus:

import operator

⎕←     ⍴    ⌿        ⍪                 ¨              ⍳                ⎕        ⎕         ⊃
print (len (reduce (operator.__add__, [map (lambda n: range (1, n+1), [input(), input()])][0])))

Je voudrais savoir s'il y a une version plus courte possible dans APL - une autre version plus simple je suis venu avec qui a plus de départage (bien que toujours à 8 caractères) est la suivante : ⍴(⍳⎕),⍳⎕.

Je n'ai vu personne le faire à la manière de l'ingénierie électrique, alors voici mon avis (en rubis):

def please_sum(a, b)
    return (a&b !=0)? please_sum( ((a&b)<<1) , a^b ):a^b
end

C'est un peu moche, mais ça fait le boulot. Les deux valeurs sont comparées au niveau du bit AND. S'ils n'ont pas de bits en commun, il n'y a pas de "report" dans la colonne binaire suivante, donc l'addition peut être complétée en les binaire XOR. S'il y a un report, vous devez ajouter le report au bit XOR. Voici un petit script rubis que j'ai utilisé pour m'assurer que ma logique numérique n'était pas trop rouillée:

100.times do
    a=rand 10
    b=rand 10
    c=please_sum(a,b)
    puts "#{a}+#{b}=#{c}"
    end

À votre santé!

Graine , 3904 3846 11 octets, 0 +/-, 10 disjoncteurs

4 141745954

Coquille, 52

read a
read b
(seq 1 $a;seq 1 $b)|wc|awk '{print$1}'

C'est essentiellement la même réponse que j'ai donnée pour un autre problème.

C

a,b;A(int a,int b){return a&b?A(a^b,(a&b)<<1):a^b;}
main(){scanf("%d%d",&a,&b);printf("%d\n",A(a,b));}

C #

Ce n'est pas le plus court par un tronçon:

private static int getIntFromBitArray(BitArray bitArray)
{
    int[] array = new int[1];
    bitArray.CopyTo(array, 0);
    return array[0];
}

private static BitArray getBitArrayFromInt32(Int32 a)
{
    byte[] bytes = BitConverter.GetBytes(a);
    return new BitArray(bytes);
}

static void Main(string[] args)
{
    BitArray first = getBitArrayFromInt32(int.Parse(Console.ReadLine()));
    BitArray second = getBitArrayFromInt32(int.Parse(Console.ReadLine()));
    BitArray result = new BitArray(32);

    bool carry = false;
    for (int i = 0; i < result.Length; i++)
    {
        if (first[i] && second[i] && carry)
        {
            result[i] = true;
        }
        else if (first[i] && second[i])
        {
            result[i] = false;
            carry = true;
        }
        else if (carry && (first[i] || second[i]))
        {
            result[i] = false;
            carry = true;
        }
        else
        {
            result[i] = carry || first[i] || second[i];
            carry = false;
        }
    }
    Console.WriteLine(getIntFromBitArray(result));
}

J, 15 7 caractères, 1 bris d'égalité, programme incomplet

Ceci est ma tentative J. Ce n'est pas un programme complet, car je n'ai pas encore compris comment en écrire un. Il suffit de mettre cette ligne dans un script pour obtenir la fonction pqui peut être utilisée pour ajouter une quantité arbitraire de nombres. C'est une monade et prend une liste de nombres à ajouter (comme p 1 2 3 4):

p=:#@#~

L'idée est très simple. La fonction est écrite dans un style tacite ou inutile. Voici une définition pointue:

p=:3 :'##~y'

Lire de droite à gauche. Dans la version tacite, @compose les parties de la fonction. (comme un ∘ en mathématiques [(f∘g) (x) = f (g (x)])

• yest le paramètre de p.
• ~rend un verbe réflexif. Pour un verbe m, m~ aest égal à a m a.
• #(copie, a#b): Chaque élément dans aest répliqué ifois, où iest l'élément au même index que l'élément actuel de aof b. Ainsi, #~réplique un élément n nfois.
• #(count, #b): compte le nombre d'éléments dans b.

Conclusion: J est génial et moins lisible que Perl (ce qui le rend encore plus génial)

Modifications

• 15 -> 7 en utilisant #au lieu de i.. Ouais! Moins de caractères que golfscript.

Plus d'un programme

Celui-ci demande des entrées, mais ce n'est toujours pas un programme complet: (13 caractères, 3 disjoncteurs)

##~".1!:1<#a:

Javascript (17 caractères de départage)

eval('걢갽거걲걯걭거건갨걡갽거걲걯걭거건갨걹갽걦걵걮걣건걩걯걮갨걡갩걻걣갽걮걥걷갠걕걩걮건갸걁걲걲걡걹갨걡갩갻걦걯걲갨걩갠걩걮갠걣갩걩걦갨걩갽갽걾걾걩갩걸갮거걵걳걨갨갱갩걽갬걸갽걛걝갩갩갻걹갨걡갩갻걹갨걢갩갻걡걬걥걲건갨걸갮걬걥걮걧건걨갩갻'['split']('')['map'](function(_){return String['fromCharCode'](_['charCodeAt'](~~[])^0xac00)})['join'](''))

: P ("Obfuscated" pour réduire le nombre de caractères de départage. En interne, c'est b=prompt(a=prompt(y=function(a){c=new Uint8Array(a);for(i in c)if(i==~~i)x.push(1)},x=[]));y(a);y(b);alert(x.length); .)

C #,

Le programme fonctionne sur 1 ligne; séparés sur plusieurs lignes pour éviter le défilement horizontal.

using C=System.Console;
class A{
static void Main(){
int a,b,x,y;
a=int.Parse(C.ReadLine());
b=int.Parse(C.ReadLine());
do{x=a&b;y=a^b;a=x<<1;b=y;}while(x>0);
C.WriteLine(y);
}}

Clojure (44 caractères)

(pr(#(count(concat(%)(%)))#(repeat(read)0)))

Edit: corrigé pour imprimer sur STDOUT au lieu de simplement renvoyer la somme.

Scala

• But:
  • + -: 0
  • (). : 5 + 5 + 3 = 13

Code:

(List.fill (readInt) (1) ::: List.fill (readInt) (2)).size

• List.fill (4) (7) produit List (7, 7, 7, 7)
• a ::: b concatène 2 listes en une
• Le reste devrait être évident

K, 11

{#,[!x;!y]}

Même astuce de concaténation que la solution R. Lecture de droite à gauche: énumérer les deux variables d'entrée, concaténer puis compter.

PowerShell , 27 42 octets, 0 +-, 4 1 secondaire

^{Merci à Mazzy d'avoir sauvé un +et 4 secondaires}

$args|%{[int[]]$_*$_}|measure|select count

Essayez-le en ligne! ou Pretty Table pour 3 octets supplémentaires

-Ou- en ajoutant quatre secondaires pour économiser 19 octets:

32 23 octets, 1 0 +-, 12 5 secondaires

^{-9 octets grâce à mazzy}

($args|%{,$_*$_}).count

Essayez-le en ligne!

Pour chaque argument, nous poussons les néléments du tableau (constitués de [n]mais ce n'est pas important) vers le pipeline qui sont regroupés par les parenthèses puis comptés.

Tonnelet (SBCS sur Keg wiki)

Fondamentalement, un port de la réponse R.

¿¿Ï_"Ï_!.

Explication

¿¿#        Take 2 integer inputs
  Ï_"Ï_#   Generate 2 arrays the length of the integer inputs
       !.# Output the length of the stack

05AB1E , 2 4 octets, 0 +/-

F>

Essayez-le en ligne!

Toutes mes excuses si j'ai mal compris ce défi, mais j'ai été surpris qu'il n'y ait pas de réponse 05AB1E. La réponse la plus courte dans cette langue que je pourrais trouver qui n'utilise pas + ou la fonction somme intégrée.

Explication:

 F   #Loop A many times
  >  #Increment B
     #(Implicit output)

-2 octets grâce à Grimy.

Python 3

Sans compter sur des sommations cachées dans d'autres fonctions.

h=input;x,y=int(h()),int(h())
while y:c=x&y;x^=y;y=c<<1
print(x)

Essayez-le en ligne!

ré

main(){
    int a,b;
    readf("%d %d",&a,&b);
    write((new int[a]~new int[b]).length);
}

cette fois en utilisant des longueurs de tableau