Es hat schon viele "Do __ without _ _" Herausforderungen gegeben, aber ich hoffe, dass dies eine der schwierigsten ist.

Die Herausforderung

Sie müssen ein Programm schreiben, das zwei natürliche Zahlen (ganze Zahlen> 0) von STDIN nimmt und die Summe der beiden Zahlen an STDOUT ausgibt. Die Herausforderung besteht darin, dass Sie so wenig +und -Zeichen wie möglich verwenden müssen. Sie dürfen keine Summen- oder Negationsfunktionen verwenden.

Beispiele

Eingang

123
468

Ausgabe

591

Eingang

702
720

Ausgabe

1422

Tie Breaker: Wenn zwei Programme die gleiche Anzahl von +und -Zeichen haben, ist der Gewinner die Person mit weniger / * ( ) = . ,und 0-9Zeichen.

Nicht zulässig: Sprachen, in denen die Standardoperatoren für Addition / Subtraktion und Inkrement / Dekrement andere Symbole als +oder -nicht zulässig sind. Dies bedeutet, dass Whitespace die Sprache nicht erlaubt.

Perl (keine +/-, keine Tie-Breaker, 29 Zeichen)

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

Als Bonus können Sie die Codesumme aus mehr als zwei Zahlen zusammensetzen, indem Sie mehr xs zu der hinzufügen s!!xx!.

Alternativ gibt es hier zwei 21-char-Lösungen mit 1 bzw. 3 Tie-Breakern

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

say log exp(<>)*exp<>

Hinweis: Diese Lösungen verwenden die sayseit Perl 5.10.0 verfügbare Funktion mit dem -EBefehlszeilenschalter oder mit use 5.010. Informationen zu Versionen, die auf älteren Perls funktionieren, finden Sie im Bearbeitungsverlauf dieser Antwort .

Wie funktioniert die Lösung ohne Kabelbinder?

• s!!xx!ist ein regexp-Ersetzungsoperator , der standardmäßig die $_Variable bearbeitet und die leere Zeichenfolge durch die Zeichenfolge ersetzt xx. (Wird /normalerweise in Perl als reguläres Begrenzungszeichen verwendet, aber es kann wirklich fast jedes Zeichen verwendet werden. Ich habe mich dafür entschieden, !da es kein Unentschieden ist.) Dies ist nur eine ausgefallene Art "xx", vor $_- oder, da $_leer zu beginnen (undefiniert, Eigentlich ist es eine Art zu schreiben, $_ = "xx"ohne das Gleichheitszeichen zu verwenden (und auch mit einem Zeichen weniger).

• s!x!$"x<>!egErsetzen jedes dieses Mal ist ein weiterer regexp Ersatz xin $_mit dem Wert des Ausdrucks $" x <>. (Der gSchalter gibt die globale Ersetzung an und egibt an, dass die Ersetzung als Perl-Code ausgewertet werden soll, anstatt als Literalzeichenfolge verwendet zu werden.) Dies $"ist eine spezielle Variable, deren Standardwert zufällig ein einzelnes Leerzeichen ist. Wenn Sie es verwenden, anstatt " "ein Zeichen zu speichern. (Jede andere Variable, von der bekannt ist, dass sie einen Ein-Zeichen-Wert hat, wie z. B. $&oder $/, würde hier genauso gut funktionieren, mit der Ausnahme, dass $/mich die Verwendung eines solchen Parameters einen Unentschieden kosten würde.)

  Der <> Zeileneingabeoperator liest im skalaren Kontext eine Zeile aus der Standardeingabe und gibt sie zurück. Das xVorher ist der Perl- Zeichenfolge-Wiederholungsoperator und ist wirklich der Kern dieser Lösung: Er gibt seinen linken Operanden (ein einzelnes Leerzeichen) zurück, der so oft wiederholt wird, wie er von seinem rechten Operanden (der gerade als Eingabe gelesenen Zeile) angegeben wurde.

• y!!!cDies ist nur eine obskure Möglichkeit, den Transliterationsoperator (ab) zu verwenden , um die Zeichen in einer Zeichenfolge zu zählen ( $_standardmäßig ebenfalls). Ich hätte gerade schreiben können say length, aber die verschleierte Version ist ein Zeichen kürzer. :)

R (24 Zeichen)

length(sequence(scan()))

Was dies bewirkt:

• scan Liest Eingaben von STDIN (oder einer Datei)
• sequencegeneriert Integer-Sequenzen ab 1 und verkettet die Sequenzen. Beispielsweise sequence(c(2, 3))ergibt sich der Vektor1 2 1 2 3
• length berechnet die Anzahl der Elemente im verketteten Vektor

Beispiel 1:

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

Beispiel 2:

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

D

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

bisschen herumspielen um den Sieg

als Bonus enthält der kompilierte Code keine Add-Operation (kann aber nicht für den readf-Aufruf sprechen)

Python 2, 43 Bytes

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

GolfScript

Keine +/- oder Tie-Breaker:

# 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

Viel einfachere Version mit zwei Breaker-Charakteren, die denselben Listenketten-Trick verwenden, den andere Leute verwenden:

~[\]{,~}%,

Ich gehe davon aus, dass GolfScript nicht )als Inkrement-Operator disqualifiziert ist , da ich es eigentlich nicht benutze.

C (nur 32 Bit)

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

Zeigerarithmetik ist genauso gut.
Wie passt es zu den Anforderungen?
* Nein +oder -
* Nein /, =, ., 0- 9
* Nur drei Paare von Klammern, die minimal mir scheint (man braucht main, scanf, printf).
* Eins *(der Zeiger-Ansatz erfordert es).
* Vier ,(könnte eins sparen, indem normale Variablen definiert werden, nicht ac,av)

C ++ 0 +/-, 3 Tie-Breaker

#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

Dies verwendet keine +oder -Zeichen und nur zwei =aus dem Satz der Tie Breaker-Zeichen, von denen eines für die Bindung obligatorisch ist main. Die Summe wird durch Verketten von Listen mit den entsprechenden Längen erreicht.

BEARBEITEN Dies wurde gepostet, BEVOR die Regeln geändert wurden, um zu verbieten sum...

Die R-Sprache: Keine Anrufe an +oder -... und 9 Breaker-Charaktere!

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

Beispiel:

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

Das [1] 579ist die Antwort 579 (das [1]ist zu verfolgen, wo in dem Ergebnisvektor Sie sind, da in R alle Werte Vektoren sind - in diesem Fall der Länge 1)

Beachten Sie, dass R +wie die meisten Sprachen Operatoren hat - es kommt nur so vor, dass es auch so viele sumVektoren hat.

In diesem Fall wird readLinesein Zeichenfolgenvektor der Länge 2 zurückgegeben. Dann erzwinge ich ihn zu numerisch (verdoppelt) und fasse ihn zusammen ...

Nur um einige andere Funktionen von R zu zeigen:

> 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

Die R-Sprache

Neue Regeln, neue Antwort, gleiche Sprache. Keine Anrufe zu +oder-

UPDATE Mit scandieser Option werden 11 (und insgesamt 27) Zeichen für den Tie-Breaker angezeigt.

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

Original: 13 Breaker-Charaktere!

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

Beispiel:

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

Diesmal wird das Ergebnis durch Matrixmultiplikation erzielt. Die Antwort wird als 1x1-Matrix angezeigt.

Haskell, 0 +/ -, 6 2 Krawattenbrecher ( =)

(verwendet nicht den String / List-Verkettungstrick)

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)

Danke an @JiminP für den ~~ Tipp! Ich gehe für die wenigsten Bytes, also spart das 1 Byte an der p = Eingabeaufforderung; ist es immer noch wert. Ich verstehe Ihre Argumentation über Tie-Breaker-Zeichen, aber um ehrlich zu sein, würden Sie nicht lieber die kleinsten Bytes :-p

Fassung, 69

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

Dank einiger Rückmeldungen von @Ilmari und @JiminP habe ich 13 Bytes meiner ursprünglichen Lösung eingespart.

Ursprünglich 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 (keine +/-, keine Verbindungsunterbrecher, 8 oder 10 Zeichen)

Dieser Eintrag ähnelt den anderen Einträgen, bei denen aus der Eingabe generierte Sequenzen verkettet und die Länge ermittelt werden. Er befindet sich jedoch in APL, was selbst bei einem kleinen Problem wie diesem verwirrend sein kann. Ich habe Dyalog APL verwendet , das eine kostenlose Bildungslizenz anbietet.

Code:

⍴⊃⍪⌿⍳¨⎕⎕

Von rechts nach links:

• Jedes quote-quad ( ⎕) fordert Eingaben vom Benutzer an und wertet diese aus.
• Jeder Operator ( ¨) wendet die Indexgeneratorfunktion ( ⍳) auf jedes der Elemente im Array auf der rechten Seite an.
• Dadurch wird das resultierende Array von Arrays zu einem Array zusammengefasst. Das Eingabearray wird vom Reduktionsoperator ( /) auf eine flache Liste reduziert , die das Array mithilfe der Verkettungsfunktion ( ,) faltet . Für diese Herausforderung wird der eindimensionale Reduktionsoperator ( ⌿) zusammen mit dem Verkettungsoperator entlang der ersten Achse ( ⍪) verwendet.
• Durch die Verwendung des Reduktionsoperators wird das Array eingeschlossen , als würde es in den Beutel gelegt. Alles, was wir von außen sehen, ist eine Tasche, nicht ihr Inhalt. Der Operator disclose ( ⊃) gibt uns den Inhalt des beiliegenden Arrays (den Beutel) an.
• Schließlich gibt die Form von function ( ⍴) die Längen der Dimensionen eines Arrays an. In diesem Fall haben wir ein eindimensionales Array, sodass wir die Anzahl der Elemente im Array erhalten, was unser Ergebnis ist.

Wenn wir das Ergebnis explizit ausgeben müssen, können wir dies folgendermaßen tun:

⎕←⍴⊃⍪⌿⍳¨⎕⎕

Vergleichbarer Python-Code mit den entsprechenden APL-Symbolen oben:

import operator

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

Ich würde gerne wissen , ob es eine kürzere Version möglich in APL ist - eine andere, einfachere Version kam ich mit , dass mehr Gleichstand hat (obwohl immer noch bei 8 Zeichen) ist: ⍴(⍳⎕),⍳⎕.

Ich habe niemanden gesehen, der es auf elektrotechnische Weise gemacht hat, also hier meine Einstellung (in Ruby):

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

Es ist ein bisschen hässlich, aber es erledigt die Arbeit. Die beiden Werte werden bitweise verglichen AND. Wenn sie keine gemeinsamen Bits haben, gibt es keinen "Übertrag" in die nächste Binärspalte, so dass die Addition durch bitweises Hinzufügen abgeschlossen werden XORkann. Wenn es einen Übertrag gibt, müssen Sie den Übertrag bitweise hinzufügen XOR. Hier ist ein kleines Rubinskript, mit dem ich sichergestellt habe, dass meine digitale Logik nicht zu verrostet ist:

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

Prost!

Seed , 3904 3846 11 Bytes, 0 +/-, 10 Tie Breaker

4 141745954

Shell, 52

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

Dies ist im Grunde die gleiche Antwort, die ich für ein anderes Problem gegeben habe.

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 #

Es ist nicht die kürzeste Strecke:

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 Zeichen, 1 Kabelbinder, unvollständiges Programm

Das ist mein Versuch. Es ist kein vollständiges Programm, weil ich noch nicht herausgefunden habe, wie man eines schreibt. Fügen Sie diese Zeile einfach in ein Skript ein, um die Funktion zu erhalten, mit der Sie peine beliebige Anzahl von Zahlen hinzufügen können. Es ist eine Monade und benötigt eine Liste von Zahlen, die hinzugefügt werden müssen (z. B. p 1 2 3 4):

p=:#@#~

Die Idee ist sehr einfach. Die Funktion ist stillschweigend oder sinnlos geschrieben. Hier ist eine spitze Definition:

p=:3 :'##~y'

Lesen Sie von rechts nach links. Fasst in der stillschweigenden Version @die Teile der Funktion zusammen. (wie ein ∘ in der Mathematik [(f∘g) (x) = f (g (x)])

• y ist der Parameter von p .
• ~macht ein Verb reflexiv. Für ein Verb m,m~ a ist gleich a m a.
• #(copy, a#b): Jedes Element in awird imal repliziert , wobei isich das Element am selben Index befindet wie das aktuelle Element avon b. So #~repliziert ein Elementn n mal.
• # (Anzahl, #b ): Zählt die Anzahl der Elemente in b.

Fazit: J ist furchterregend und weniger lesbar als Perl (was es noch furchterregender macht)

Bearbeitungen

• 15 -> 7 verwenden #statti. . Ja! Weniger Zeichen als Golfscript.

Eher ein Programm

Dieser fragt nach Eingaben, ist aber noch kein vollständiges Programm: (13 Zeichen, 3 Unterbrecher)

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

Javascript (17 Breaker-Charaktere)

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

: P ("Verschleiert", um die Anzahl der Trennzeichen zu verringern. Intern ist es 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 #,

Programm funktioniert in 1 Zeile; Auf mehreren Zeilen getrennt, um horizontales Scrollen zu vermeiden.

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

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

Bearbeiten: Behoben, auf STDOUT zu drucken, anstatt nur die Summe zurückzugeben.

Scala

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

Code:

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

• List.fill (4) (7) erzeugt List (7, 7, 7, 7)
• a ::: b verknüpft 2 Listen zu einer
• Der Rest sollte offensichtlich sein

K, 11

{#,[!x;!y]}

Gleicher Verkettungstrick wie die R-Lösung. Lesen von rechts nach links: Zählen Sie die beiden Eingabevariablen auf, verketten Sie sie und zählen Sie sie dann.

PowerShell , 27 42 Bytes, 0 +-, 4 1 sekundär

^{Danke an mazzy für das Speichern von a +und 4 Secondaries}

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

Probieren Sie es online! oder Pretty Table für zusätzliche 3 Bytes

-Oder- Hinzufügen von vier Sekunden, um 19 Bytes zu sparen:

32 23 Bytes, 1 0 +-, 12 5 Sekunden

^{-9 bytes dank mazzy}

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

Probieren Sie es online!

Für jedes Argument verschieben wir nArray-Elemente (bestehend aus, [n]aber das ist nicht wichtig) in die Pipeline, die von den Parens gruppiert und dann gezählt werden.

Fass (SBCS im Keg-Wiki)

Grundsätzlich ein Port der R-Antwort.

¿¿Ï_"Ï_!.

Erläuterung

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

05AB1E , 2 4 Bytes, 0 +/-

F>

Probieren Sie es online!

Entschuldigung, wenn ich diese Herausforderung missverstanden habe, aber ich war überrascht, dass es keine 05AB1E-Antwort gab. Die kürzeste Antwort in dieser Sprache, die ich finden könnte, verwendet weder + noch die eingebaute Summenfunktion.

Erläuterung:

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

-2 Bytes dank Grimy.

Python 3

Ohne sich auf versteckte Summierungen in anderen Funktionen zu verlassen.

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

Probieren Sie es online!

D

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

diesmal mit Arraylängen