Daha önce birçok " _ __ yapmadan Do _" zorlukları oldu, ama umarım bu en zorlayıcılardan biri.

Meydan okuma

STDIN'den iki doğal sayı (tam sayı> 0) alan ve iki sayının toplamını STDOUT'a yazdıran bir program yazacaksınız. Buradaki zorluk mümkün olduğunca az kullanmanız +ve -işaretler kullanmanız gerektiğidir . Toplama benzeri veya olumsuzlama işlevlerini kullanmanıza izin verilmez.

Örnekler

giriş

123
468

çıktı

591

giriş

702
720

çıktı

1422

Kırıcı Tie: iki program aynı sayısını varsa +ve -karakter kazanan az olan kişidir / * ( ) = . ,ve 0-9karakterler.

İzin Verilmiyor: Standart toplama / çıkarma ve artırma / azaltma operatörlerinin hangi simgelerden başka simgeler olduğu +veya -izin verilmeyen diller . Bu, Boşluk diline izin verilmediği anlamına gelir.

Perl (+/- yok, bağlayıcı yok, 29 karakter)

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

Bir bonus olarak, daha ekleyerek iki sayı daha kod toplamı daha yapabilir xüzere s s!!xx!.

Alternatif olarak, burada sırasıyla 1 ve 3 tie-breaker ile iki adet 21 şeritli çözüm

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

say log exp(<>)*exp<>

Not: Bu çözümler say, -Ekomut satırı düğmesiyle veya ile Perl 5.10.0'dan beri kullanılabilen işlevi kullanır use 5.010. Eski perls'de çalışan sürümler için bu cevabın düzenleme geçmişine bakın .

Bağ kırıcı içermeyen çözüm nasıl çalışır?

• s!!xx!boş dizeyi dize ile değiştiren değişken üzerinde varsayılan olarak çalışan bir regexp değiştirme işlecidir . (Genellikle , Perl'deki regexp sınırlayıcı olarak kullanılır, ancak gerçekten hemen hemen her karakter kullanılabilir. Kravat kırıcı olmadığından seçtim .) Bu, sadece hazırlıklı olmanın güzel bir yolu - veya, boş başladığından beri (tanımsız, aslında), eşittir işaretini kullanmadan yazmanın bir yoludur (ve bir karakter daha az).$_xx/!"xx"$_$_$_ = "xx"

• s!x!$"x<>!egBaşka bir düzenli ifade yerine, bu kez, her yerine olup xiçinde $_ifade değeri ile $" x <>. ( gAnahtar küresel değiştirme belirtir eyedek bir dize olarak kullanılıyor yerine Perl kodu olarak değerlendirilmesi gereken belirtir.) $"Bir olduğu özel değişken olan Varsayılan değer tek bir boşluk olur; " "Bir karakter yerine onu kullanmak bir karakter kaydeder. ( $&Veya gibi bir karakterlik bir değere sahip olduğu bilinen herhangi bir değişken $/burada eşit derecede iyi çalışır, bunun kullanılması $/bana bir kırıcıya mal olur.)

  <> Hat girişi operatörü , skaler bağlamda, standart girdi ve getiri ondan bir satır okur. xPerl önce dize tekrarı operatörü ve gerçekten bu çözümün çekirdeğidir: onun sol işlenen (tek bir boşluk karakteri) sağ işlenenindeki tarafından verilen sayısını tekrarlanan döndürür (hat biz sadece girdi olarak okuyun).

• y!!!c(ab) harfleri bir karakter dizisinde saymak için transliterasyon operatörünü kullanmak için sadece belirsiz bir yöntemdir ( $_varsayılan olarak, yine). Daha yeni yazabilirdim say length, ancak şaşkın sürüm bir karakterden daha kısa. :)

R (24 karakter)

length(sequence(scan()))

Bu ne yapar:

• scan STDIN'den (veya bir dosyadan) girişi okur
• sequence1'den başlayarak tam sayı dizileri oluşturur ve dizileri birleştirir. Örneğin sequence(c(2, 3)), vektörde sonuçlar1 2 1 2 3
• length birleştirilmiş vektördeki öğelerin sayısını hesaplar

Örnek 1:

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

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

biraz kazanmak için twiddling

Bonus olarak, derlenen kod bir ekleme işlemi içermez (okuma çağrısı için konuşamamaktadır).

Python 2, 43 bayt

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

GolfScript

+/- veya bağ kesici yok:

# 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

Diğer insanların kullandığı aynı liste birleştirme hilesini kullanarak iki tie-break karakteriyle daha basit sürüm:

~[\]{,~}%,

GolfScript'in )bir artırma operatörü olarak kullanım için diskalifiye edilmediğini farz ediyorum, aslında kullanmadığım için.

C (yalnızca 32bit)

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

İşaretçi aritmetiği de aynı derecede iyidir.
Gereksinimlere nasıl uyuyor?
* Hiçbir +veya -
* Hayır /, =, ., 0- 9
* bana minimal (İhtiyacınız görünüyor parantez sadece 3 çift, main, scanf, printf).
* Bir *(işaretçi yaklaşımı gerektirir).
* Dört ,(normal değişkenleri tanımlayarak birini kurtarabilir, değil ac,av)

C ++ 0 +/-, 3 bağlantı kesici

#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

Bu, hayır +veya -karakter kullanır ve =bunlardan sadece ikisi bağlayıcılık için zorunlu olan bağlantı kesici karakter kümesinden yalnızca ikisini kullanır main. Toplam, uygun uzunluktaki listeleri birleştirerek yapılır.

EDIT Bu, kurallara izin verilmeksizin değiştirilmeden ÖNCE gönderildi sum...

R dili: Arama yok +veya -... Ve 9 beraberlik karakter!

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

Örnek:

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

[1] 579Cevap 579 (olan [1]R tüm değerler vektörler çünkü senin nerede sonuç vektörü içinde takip etmektir - uzunluğu 1 bu durumda)

R'nin +birçok dilde olduğu gibi operatörlere sahip olduğuna dikkat edin - öyle olur ki sumbir sürü vektörü de özetler.

Bu durumda, readLines2 uzunluğunda bir dize vektörü döndürür. Sonra onu sayısal olarak zorlarım (çiftler) ve toplarım ...

Sadece R'nin diğer bazı özelliklerini göstermek için:

> 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

R dili

Yeni kurallar, yeni cevap, aynı dil. Arama yok +veya-

GÜNCELLEME Kullanarak scan, 11 kravat kesici karaktere (ve tümü 27 karaktere) düşer.

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

Orijinal: 13 kravatcı karakter!

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

Örnek:

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

Bu kez sonuç matris çarpımı ile elde edilir. Cevap 1x1'lik bir matris olarak görüntülenir.

Haskell, 0 +/ -, 6 2 bağ kırıcılar ( =)

(string / list bitiştirme numarasını kullanmaz)

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)

~~ ipucundaki @JiminP'e teşekkürler! En az bayt için gidiyorum, p = isteminde 1 bayt tasarruf; hala buna değer. Tie-break karakterleri hakkındaki argümanınızı anlıyorum, ama dürüst olmak gerekirse en az bayt tercih eder misiniz?

Sürüm, 69

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

@Ilmari ve @JiminP'den gelen geri bildirimler sayesinde, orijinal çözümümden 13 byte'ı geçtim.

Orijinal olarak, 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 (+/- yok, bağlantı kesici yok, 8 veya 10 karakter)

Bu giriş, girişten oluşturulan dizileri birleştirip uzunluğu bulanlara benzer ... ancak bu gibi küçük bir problem için bile kafa karıştırıcı görünen APL'de. Ücretsiz bir eğitim lisansı sunan Dyalog APL'yi kullandım .

Kod:

⍴⊃⍪⌿⍳¨⎕⎕

Sağdan sola doğru:

• Her quote-quad ( ⎕) kullanıcıdan girdi ister ve değerlendirir.
• Her operatör ( ¨), dizin oluşturucu işlevini ( ⍳) dizideki öğelerin her birine sağındaki uygular .
• Bu, sonuçta ortaya çıkan dizi dizisini bir diziye yassılaştırır. Giriş dizisi, /birleştirme işlevini ( ,) kullanarak diziyi katlayan redüksiyon operatörü ( ) tarafından düz bir listeye indirgenir . Bu zorluğun uğruna ⌿, ilk eksen ( ⍪) boyunca birleştirme operatörü ile birlikte bir boyutlu küçültme operatörü ( ) kullanılır .
• İndirgeme operatörü kullanılmasının bir sonucu olarak, bir dizi olan kapalı çantaya yerleştirerek gibi olan; Dışarıda gördüğümüz tek şey bir çanta, içeriği değil. Açıklama operatörü ( ⊃) bize ekteki dizinin (çanta) içeriğini verir.
• Son olarak, function-işlevi ( ⍴) bize bir dizinin boyutlarının uzunluklarını verir. Bu durumda, tek boyutlu bir dizimiz var, bu nedenle dizideki sonuç sayısını elde ettiğimiz öğe sayısını elde ediyoruz.

Açıkça sonucu çıkarmak gerekirse, şöyle yapabiliriz:

⎕←⍴⊃⍪⌿⍳¨⎕⎕

Yukarıdaki APL sembolleriyle karşılaştırılabilir Python kodu:

import operator

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

Ben APL mümkün kısa versiyonu olup olmadığını bilmek istiyorum - Başka, daha basit sürüm I (hala 8 karakter rağmen) olduğunu daha kravat kesiciler vardır ile geldi: ⍴(⍳⎕),⍳⎕.

Elektrik Mühendisliği yolunda kimsenin yaptığını görmedim, bu yüzden işte benim aldığım (yakutlu):

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

Biraz çirkin, ama işi halleder. İki değer bit değeriyle karşılaştırılır AND. Ortak uçları yoksa, bir sonraki ikili sütuna bir "taşıma" yoktur, bu yüzden ekleme XORbunları bitsel olarak tamamlayarak tamamlanabilir . Bir taşıma varsa, taşıma işlemini bit yönünde eklemek zorundasınız XOR. Dijital mantığımın çok paslı olmadığından emin olmak için kullandığım küçük bir yakut senaryosu:

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

Şerefe!

Tohum , 3904 3846 11 bayt, 0 +/-, 10 bağlantı kesici

4 141745954

Kabuk, 52

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

Bu temelde başka bir soruna verdiğim cevapla aynı .

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 #

Herhangi bir streç tarafından en kısa değil:

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 karakter, 1 bağ kırıcı, tamamlanmamış program

Bu benim J girişimim. Bu tam bir program değil, çünkü nasıl yazacağımı henüz çözemedim. pİsteğe bağlı sayıda sayı eklemek için kullanılabilecek işlevi almak için bu satırı bir komut dosyasına koyun . Bu bir monad ve eklenecek sayıların bir listesini alır (örneğin p 1 2 3 4):

p=:#@#~

Fikir, çok basit. İşlev, tam anlamıyla aka anlamsız stilde yazılmıştır. İşte sivri bir tanım:

p=:3 :'##~y'

Sağdan sola okuyun. Tacik versiyonda, @fonksiyonun bölümlerini oluşturur. (matematikteki bir like gibi [(f∘g) (x) = f (g (x)])

• yparametresidir p.
• ~fiili refleksif hale getirir. Bazı fiil için m, m~ aeşittir a m a.
• #(kopyalama, a#b): Her eleman açoğaltılır ikez nerede işimdiki unsuru olarak aynı dizinde unsurdur aarasında b. Böylece, #~bir öğe n nzamanlarını çoğaltır .
• #(count, #b): içindeki öğelerin sayısını sayar b.

Sonuç: J, Perl'e göre daha az okunaklı ve daha az okunaklıdır (bu da daha fazla merak uyandırıcıdır)

Düzenlemeler

• 15 -> 7 #yerine i.. Evet! Golf senaryosundan daha az karakter.

Bir programın fazlası

Bu girdi için sorgular, ancak hala tam bir program değil: (13 karakter, 3 kırıcı)

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

Javascript (17 kravat kırıcı karakter)

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

: P (Kırıcı karakter sayısını azaltmak için "Karışık"). Dahili olarak 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 #,

Program 1 satırda çalışıyor; Yatay kaydırmayı önlemek için birden fazla satıra ayrılmıştır.

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

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

Düzenleme: yalnızca toplamı döndürmek yerine STDOUT'a yazdırması düzeltildi.

Scala

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

Kod:

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

• Liste dosyası (4) (7) Liste (7, 7, 7, 7) üretir
• a ::: b 2 Listeyi bir araya getirir
• Gerisi açık olmalı

K, 11

{#,[!x;!y]}

R çözümü ile aynı bitiştirme numarası. Sağdan sola okuma: İki giriş değişkenini numaralandırın, birleştirin ve sayın.

PowerShell , 27 42 bayt, 0 +-, 4 1 ikincil

^{Bir +ve 4 ikincil tasarruf için mazzy sayesinde}

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

Çevrimiçi deneyin! veya fazladan 3 bayt için hoş tablo

-VEYA- 19 bayt kurtarmak için dört saniye ekleme:

32 23 bayt, 1 0 +-, 12 5 sekonder

^{Mazzy sayesinde -9 bayt}

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

Çevrimiçi deneyin!

Her argüman için, ndizi elemanlarını (bunlardan ibarettir [n]ama önemli değildir), parenler tarafından gruplanan ve sonra sayılan boru hattına iteriz.

Fıçı (Fıçı wiki'deki SBCS)

Temel olarak R cevabının bir limanı.

¿¿Ï_"Ï_!.

açıklama

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

05AB1E , 2 4 bayt, 0 +/-

F>

Çevrimiçi deneyin!

Bu sorunu yanlış anladıysam özür dilerim, ancak 05AB1E cevabı olmadığına şaşırdım. Bu dilde bulabildiğim en kısa cevap, + ya da yerleşik toplam işlevini kullanmadığı sonucuna varabilirim.

Açıklama:

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

Grimy sayesinde -2 bayt.

Python 3

Diğer fonksiyonlardaki gizli toplamlara güvenmeden.

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

Çevrimiçi deneyin!

D

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

dizi uzunluklarını kullanarak bu kez