9

आपको 2 स्ट्रिंग इनपुट लेने हैं और इन दोनों तारों के योग को बिना किसी संख्यात्मक डेटा प्रकार के इंट या उपयोग किए बिना परिवर्तित करना है।

पूर्व।

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

मान लें कि तार 10 अंकों से बड़े नहीं होंगे।

यह वर्ण जीत में कोड गोल्फ और सबसे छोटा जवाब है। C # में उत्तर को संपादित करने से मुझे मुस्कुराहट मिलेगी :)।

संपादित करें: int में परिवर्तित होने को इस प्रकृति की किसी भी चीज़ के रूप में परिभाषित किया जा सकता है

Int.TryParse, (int), Convert.ToIntआदि

code-golf string arithmetic

— CSharper
स्रोत

2

जब तक हम स्ट्रिंग्स को संख्याओं में परिवर्तित नहीं कर रहे हैं, तब तक क्या हम अपने कोड में कहीं और संख्याओं का उपयोग कर सकते हैं?

— ऑप्टिमाइज़र

5

उन्हें अंतर के रूप में व्याख्या करने के विपरीत, उन्हें int में परिवर्तित करने के रूप में क्या परिभाषित किया गया है?

— कंपास

4

मैं अभी भी पूरी तरह से स्पष्ट नहीं हूं कि हम चरित्र कोड के साथ कितना कर सकते हैं? क्या हम वर्ण कोड घटा सकते हैं? क्या हम व्यक्तिगत अंकों को उनके चरित्र कोड में बदल सकते हैं?

— मार्टिन एंडर

5

@ user15681218 निश्चित रूप से यह कर सकता है। लेकिन यह आपके नियमों से पूरी तरह से स्पष्ट नहीं है कि हम वास्तव में क्या कर सकते हैं और क्या नहीं।

— मार्टिन एंडर

2

मुझे नहीं लगता है कि यह सवाल एड के बिना (या 4 मूल अंकगणित ऑपरेटरों में से कोई भी) का एक डूप है । वास्तव में, यह सवाल इस संख्या के बिना गुणा के समान है, बिना जोड़ के प्रश्न की तुलना में गुणा । बहुविकल्पीय प्रश्न को भी शुरू में बिना जोड़ के एक प्रकार का पौधा माना जाता था।

— ऑप्टिमाइज़र

16

80836 विधानसभा ( 57 53 बाइट्स)

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

यह जोड़ता है, अंकों द्वारा अंक, बाएं से दाएं, '0'-'9'पूर्णांक में एएससी अंकों को परिवर्तित किए बिना 0-9और आवश्यकतानुसार ले जाने पर। बाइटकोड एक फ़ंक्शन के लिए कोड है, जिसे C (नीचे देखें) में बुलाया जा सकता है।

उपरोक्त बाइटकोड को निम्नलिखित विधानसभा (NASM- शैली, टिप्पणी द्वारा) द्वारा हाथ से लिखा गया था:

; 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

C (gcc, linux, Intel processor) में इसे आज़माने के लिए:

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

— es1024
स्रोत

14

रूबी, 109 71

घटिया। अगर आप मोहम्मद को पहाड़ पर नहीं ला सकते ...।

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

कलन विधि:

इनपुट 1 और इनपुट 2 के लिए एक इंट्रा स्ट्रिंग प्रतिनिधित्व की तुलना करें।
प्रति मैच परिणाम के लिए उस int जोड़ें।
वृद्धि और दोहराना जब तक आप इसे दो बार कर चुके हैं।
खुद पर उल्टी

बदलाव का

एक सरणी के रूप में 71 छोटे।

85 हटाए गए विधि घोषणा और कॉल को समेकित करना n.to_s

92 ने कुछ सुझाव दिए

101 एक चार को बचाओ

वेतन वृद्धि के लिए 102 का उपयोग करें

109 प्रारंभिक प्रतिबद्ध

— चार्ल्स नहीं
स्रोत

2

@DigitalTrauma ओह, मुझे लगता है कि यह एक भयानक जवाब है, लेकिन यह निश्चित रूप से मानदंडों को पूरा करता है।

— नहीं कि

1

@DigitalTrauma मेरी भी चीज़ जवाब देता है succया prev.... लेकिन यह भी गोल्फ के लिए मजेदार नहीं है।

— नहीं कि

1

"... बिना किसी संख्यात्मक डेटा प्रकार के इंट या उपयोग करने के लिए उन्हें परिवर्तित किए बिना ।" आपके उत्तर में, r, n, d और x सभी न्यूमेरिक हैं। साथ ही, प्रत्येक पूर्णांक को यह देखने के लिए जांचता है कि क्या उसका स्ट्रिंग प्रतिनिधित्व दर्ज किए गए स्ट्रिंग से मेल खाता है या नहीं, अनिवार्य रूप से इंट में बदलने के लिए एक धीमी गति से बल तरीका है।

— ट्रे थॉमस

1

@TreyThomas, Codegolf.stackexchange.com/questions/41833/…

— नहीं कि चार्ल्स

1

@ ट्रेथोमस: मुझे लगता है कि दो मात्राओं को किसी तरह निर्धारित किए बिना उन्हें जोड़ना असंभव है। इस प्रश्न का उत्तर देने के लिए किसी भी कोड को i + j गणना करनी होती है और पता होता है कि उसके पास रुकने का सही उत्तर है, इसलिए किसी भी सही उत्तर को किसी तरह से प्रच्छन्न रूप में परिवर्तित करने के लिए एक धीमी गति से बल का तरीका है ।

— TessellatingHeckler

10

सेड, 359 बाइट्स (फैंटेसी फॉर्मेटिंग के बिना)

मुझे अब भी यकीन नहीं है कि यह जोड़ के बिना (या 4 मूल अंकगणित संचालकों में से एक) है । इस बीच, मुझे उस प्रश्न के लिए अपना उत्तर पोस्ट करने दें। यह किसी भी गोल्फ को जीतने नहीं है, लेकिन इसकी शुरुआत है, और मुझे लगता है कि यह आसानी से कल्पना को पूरा करता है:

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

इनपुट "x y" के रूप में STDIN से लिया गया है। यह पहली बार "x: 0 :: y:" में बदल गया है। फिर हम ":" वर्णों के बाद आने वाले सभी संख्याओं को बढ़ाते हैं, जब तक कि हम "x: x: :( x + y):" प्राप्त नहीं कर लेते। फिर हम अंत में लौटते हैं (x + y)।

उत्पादन

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

ध्यान दें कि यह केवल प्राकृतिक संख्याओं के लिए काम करता है। हालांकि (सिद्धांत में कम से कम) यह मनमाने ढंग से बड़े पूर्णांकों के लिए काम करता है। क्योंकि हम y पर x इंक्रीमेंट ऑपरेशन कर रहे हैं, इसलिए ऑर्डर करने से स्पीड पर बड़ा फर्क पड़ सकता है: x <y x> y से तेज होगा।

— डिजिटल आघात
स्रोत

निश्चित नहीं है, लेकिन आप कैसे जानते हैं कि वेतन वृद्धि कब रोकनी है? चूँकि आप X को इंट के रूप में नहीं पढ़ सकते हैं ..

— ऑप्टिमाइज़र

@Optimizer वेतन वृद्धि एल्गोरिदम इस पर आधारित है: codegolf.stackexchange.com/questions/38033/… जो विशुद्ध रूप से रेगेक्स प्रतिस्थापन और कोई अंकगणित नहीं है। हम एक ट्रिपल {x, 0, y} के साथ शुरू करते हैं, फिर वेतन वृद्धि के तत्व 2 और 3 तक तत्व 1 और 2 समान हैं (फिर से रेगेक्स-परीक्षण)। उस बिंदु पर तीसरा तत्व आवश्यक योग होगा।

— डिजिटल ट्रॉमा

2

ओह! तो सिर्फ रेगेक्स का उपयोग करके yपरिवर्तित किया जाता है y+1? और कोई वास्तविक जोड़ नहीं है? अच्छा!

— ऑप्टिमाइज़र

9

रूबी - 485 432 265

यह इस बात की भावना में अधिक लगता है कि आप प्रश्न में क्या देख रहे थे।

यह मूल रूप से इस समस्या को हल करता है कि कागज पर एक मानव कैसे होगा - सभी एकल अंकों के अतिरिक्त परिणामों को "याद" करके, प्रत्येक कॉलम को जोड़कर, और यह समझकर कि आवश्यक होने पर "एक को कैसे ले"।

यह एक "संख्यात्मक डेटा प्रकार" (चर i) का उपयोग भी कर रहा है, जो प्रश्न द्वारा निषिद्ध है, लेकिन इसकी केवल स्ट्रिंग अनुक्रमण के लिए है। मैं इसे हटाने की कोशिश करूंगा और अपना उत्तर संपादित करूंगा।

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

कुछ हद तक असंयमी:

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

संपादित करें: टिप्पणी से कुछ विचारों का उपयोग केवल "हार्डकोड" के बजाय "मेमोरेटेड" मैपिंग टेबल बनाने के लिए किया।

— ट्रे थॉमस
स्रोत

1

आप शायद किसी भी तरह अपने "अतिरिक्त मानचित्र" की गणना कर सकते हैं ... शायद[?1..?9].zip([?1..?9]).map{|x,y| Regex.new(x+y)}.map{/*something based on the order of results*/}

— नहीं कि चार्ल्स

productसे बेहतर हैzip

— नहीं कि

1

/#{x+y}/से छोटा है Regexp.new(x+y)। ;)

— जॉर्डन

1

i=-1;(s=(?0..?9).to_a).product(s).map{|x,y|i+=1;/#{x+y}/=>(?0..'18').each_cons(10).to_a[i/10][i%10]}आप अपने regex सरणी देता है।

— नहीं कि चार्ल्स

आह ... लेकिन जो एक संख्यात्मक ( i) का उपयोग करता है ... उसके चारों ओर एक और तरीका होना चाहिए ... शायद बस each_cons(10)एक एन्यूमरेटर और nextसेट के माध्यम से उपयोग करें ?

— चार्ल्स

4

CJam, 95 92 80 72 70 44 अक्षर

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

जिसका अनुवाद है

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

यह निश्चित रूप से बहुत गोल्फ हो सकता है। मैं वास्तव में नहीं जानता कि मेरा दृष्टिकोण इष्टतम है या अभी तक नहीं है।

अद्यतन - बाइट को बचाने के लिए योग मैट्रिक्स निर्माण को इनलाइन करें। इसके कारण, कार्यक्रम अब 10 गुना धीमा चलता है, लेकिन फिर भी किसी भी तरह के इनपुट के लिए एक निरंतर समय है।

इसे यहाँ ऑनलाइन आज़माएँ

STDIN से दो नंबरों वाली लाइन को स्ट्रिंग के रूप में पढ़ता है और वर्णों के एक सरणी के रूप में आउटपुट करता है जो एक स्ट्रिंग ही है।

उदाहरण के लिए:

123 4567

आउटपुट में पूर्ववर्ती है 0। मुझे पता है कि अगर यह एक मुद्दा है।

— अनुकूलक
स्रोत

4

सी # - 128 108 104

सुधार का सुझाव देने के लिए कम्पास, बीएमएसी और शॉन का धन्यवाद।

पहले कोड गोल्फ में प्रयास करें, और C # का उपयोग करके यहां एक बाधा प्रतीत होती है ...

उपयोग करके .Compute()आप स्ट्रिंग मान का उपयोग कर सकते हैं और उन्हें सीधे योग कर सकते हैं। एक बोनस के रूप में यह सिर्फ "+" से अलग अन्य ऑपरेटरों के लिए काम करता है।

golfed:

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

Ungolfed:

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

कॉलिंग t("123","456");आपको 579 मिलती है।

— माइकल मैकग्रिफ
स्रोत

7

अच्छा प्रयास करें, और PPCG में आपका स्वागत है। में कोड गोल्फ , हम सभी अनावश्यक सफेद स्थान निकाल कर कहते हैं कि कितने बाइट्स हम इस्तेमाल किया।

2

अगर आपको लगता है कि C # एक विकलांग है, तब तक प्रतीक्षा करें जब तक आप जावा के साथ फ़िगलिंग शुरू नहीं करते ...

— Rodolfo Dias

1

आप गणना कॉल में एक + "+" + बी को स्थानांतरित करके लाइनों को बचा सकते हैं और घोषणा को अनदेखा कर सकते हैं।

— कंपास

1

आप नामस्थानों का 'उपयोग नहीं' करके अधिक बचत कर सकते हैंSystem.Console.WriteLine(new System.Data.DataTable()...

— बीएमएसी

1

कुछ नहीं कहते हैं कि उत्पादन को एक नई रेखा के साथ समाप्त करने की आवश्यकता है, Console.Write4 बाइट बचाने के लिए उपयोग करने पर विचार करें

— SLuck49

3

GNU सेड, 266 बाइट्स

DigitalTrauma के समाधान की तुलना में एक अलग दृष्टिकोण का उपयोग करता है। एक प्रभाव के रूप में, यह O (m + n) का उपयोग करके और भी खराब प्रदर्शन करता है । दोनों ऑपरेंड को यूनीरी, कॉन्टेनेट में कनवर्ट करें, वापस दशमलव में बदलें (सभी रीजेक्स का उपयोग करते हुए - sed में पूर्णांक की अवधारणा नहीं है )।

एक बोनस के रूप में, यह प्रोग्राम स्टड पर दिए गए सभी प्राकृतिक पूर्णांक (पहली पंक्ति में) को पूरा करता है, जिसका अर्थ है कि आप इसे कुछ भी नहीं, एक नंबर या दस नंबर फ़ीड कर सकते हैं और यह सही काम करेगा।

इस कोड के पीछे का विचार अस्पष्ट रूप से मेरा एक पुराना PPCG sed प्रस्तुतिकरण से प्रेरित है, हालाँकि मुझे याद नहीं है कि यह किस प्रश्न का उत्तर है।

यहाँ यह "सुंदर" है, आपकी "सुविधा" के लिए, डिजिटलट्रामा से एक और विचार उधार लेने के लिए। : डी

                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#

(266-बाइट संस्करण प्राप्त करने के लिए, अर्धविराम, प्रमुख व्हाट्सएप और अंतिम टिप्पणी को हटा दें, अधिमानतः सेड का उपयोग करके।)

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

मैंने वास्तव में बड़े परीक्षणों को एक भयानक स्थान (इन) दक्षता के कारण थोड़ा छोटा किया। qकेवल पहली पंक्ति के उपयोग के कारण संसाधित किया जाता है, इसलिए whileपरीक्षण में लूप।

— जुगनू
स्रोत

2

जावा 6 (181 अक्षर)

अपने सभी महिमा में सी # , जावा के रूप में जाना जाने वाले विकलांग द्वारा पार नहीं किया जाना चाहिए । इतना बॉयलर! उपयोग एक स्थान द्वारा अलग किए गए तर्कों को प्रदान कर रहा है, अर्थात123 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]));}}

Ungolfed:

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

में उपलब्ध जावास्क्रिप्ट इंजन का उपयोग करके javax, हम एक और भाषा हमारे लिए काम कर सकते हैं, और तकनीकी रूप से मूल भाषा में किसी भी संख्यात्मक प्रकार का उपयोग नहीं करने या परिवर्तित करने के नियमों का पालन कर सकते हैं।

उपयोग करने का औचित्य `eval`

हमने जावास्क्रिप्ट को विकसित करने के लिए मानों को रूपांतरित नहीं किया है। हमने एक स्ट्रिंग बनाई है "123+456"जो एक संख्या नहीं है। जेएस इंजन सूत्र को पचाता है और स्ट्रिंग का मूल्यांकन संख्या शाब्दिक के रूप में करता है, जो संख्यात्मक डेटा प्रकार नहीं हैं। जावा घटिया तर्क! एक तरफ के रूप में, यह भी doubleगणित के लिए काम करता है ।

— दिशा सूचक यंत्र
स्रोत

आप बस एक bash संस्करण की मांग कर रहे हैं जैसे कि dc -e"$1 $2+p" तकनीकी रूप से मैंने देशी bash में एक नंबर प्रकार का उपयोग नहीं किया है यह सिर्फ कुछ कार्यान्वयन विवरण के लिए एक स्ट्रिंग पास कर रहा है

— TessellatingHeckler

2

एपीएल (61)

मुझे लगता है कि यह नियमों के अंतर्गत आता है।

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

यह एक फ़ंक्शन है जो दो स्ट्रिंग तर्क लेता है, और एक स्ट्रिंग लौटाता है:

      '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

यह बहुत तेजी से बहुत तेज है, यह 999999 में गठित संख्या 9को एक पल में ही जोड़ देता है ।

यह प्रत्येक वर्ण के सूचकांक को ढूँढता है ⎕D(जो कि स्ट्रिंग '0123456789' है), फिर अलग-अलग ले जाने वाले प्रत्येक सूचकांक पर ग्रेड स्कूल को अलग करता है, फिर परिणामी अंकों को देखता है ⎕D। (मुझे लगता है कि ⎕Dलुकअप नियमों के अंतर्गत आता है, यह मूल रूप से बस कर रहा है 'x'-48)।

स्पष्टीकरण:

⎕D∘⍳¨⍺⍵: ⎕Dदोनों तारों में प्रत्येक वर्ण के लिए सूचकांकों को देखें ।
¯1+: 1प्रत्येक से घटाएँ , क्योंकि सरणियाँ डिफ़ॉल्ट रूप से 1-आधारित हैं।
⌽↑⌽¨: दोनों को उल्टा करें, एक मैट्रिक्स में बदलें (शून्य वर्ग को भरने के साथ), फिर मैट्रिक्स को उल्टा करें।
+⌿: मैट्रिक्स के कॉलम का योग करें
{... }: पर ले:
- ∨/T←9<Z←0,⍵: 0सूची के सामने एक अतिरिक्त जोड़ें । पता करें कि कौन से 'अंक' 9 से अधिक हैं, और इसमें स्टोर करें T। यदि कोई अंक 10 से अधिक थे:
  - Z-10×T: 10प्रत्येक स्थिति से घटाएं जो 10 से अधिक है,
  - T←(1⌽T)+: 1प्रत्येक स्थिति के बगल में प्रत्येक स्थिति में जोड़ें जो 10 से अधिक थी, और इसमें स्टोर करें T।
  - T↓⍨~×⊃T: यदि Tएक शून्य से शुरू होता है, तो इसे हटा दें,
  - ∇: परिणाम के लिए कैरी फंक्शन लागू करें।
- ⋄⍵: अन्यथा, अपरिवर्तित मान लौटाएं
1+: प्रत्येक स्थिति में एक जोड़ें (क्योंकि सरणी 1-अनुक्रमित है)
⎕D[... ]: परिणाम को सूचकांकों के रूप में उपयोग करें ⎕D।

— मारीनस
स्रोत

2

पर्ल - 136 119 115 बाइट्स

मैं पर्ल सीख रहा हूं, यह अच्छा अभ्यास था। सुझावों की सराहना की है!

पनीर उत्तर, रास्ते से हटने के लिए:

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

वास्तविक उत्तर:

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

असम्पीडित:

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

— BMac
स्रोत

2

अच्छा लगा। अपने नंबर को थोड़ा कम करने के लिए आप इन युक्तियों की जांच कर सकते हैं । एक नज़र में, अपनी पहली पंक्ति को बदलने ($x,$y)=@ARGVऔर उपयोग sayकरने के बजाय printकुछ वर्णों को छोड़ देंगे।

— मार्क

धन्यवाद! मैंने ऐसा ही किया और कुछ परेंसन्स निकाले (मुझे विराम के दृष्टिकोण से प्यार है)। मैं हालांकि काम करने के लिए नहीं कह सकता।

— बीएमएसी

आह। sayएक पर्ल 6 चीज़ है (या आप इन निर्देशों के साथ पर्ल 5 में इसका इस्तेमाल कर सकते हैं , लेकिन यह बहुत लंबा होगा)। इसके बजाय say, warnएक चरित्र को दाढ़ी बनाने के लिए उपयोग करें। यह STDOUT के बजाय STDERR को आउटपुट देगा, लेकिन यह इस नियम के विरुद्ध नहीं है। :-)

— मार्क

0

जावा 7, स्कोर = 252

कोई पूर्णांक, लोंग्स, बाइट्स, शॉर्ट्स, डबल्स, फ्लोट्स, या जोड़ने के लिए पुस्तकालय कार्यों में निर्मित किसी भी उपयोग करता है। एक वर्ग शरीर में लपेटें और साथ बुलाएं t(String1,String2)। कृपया पैड स्ट्रिंग्स को 0 के साथ रखें ताकि उनकी लंबाई समान हो।

t("123","234")लौटता है "0357"।

golfed:

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

गोल्फ क्लास के साथ विस्तारित:

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

आंशिक रूप से गोल्फ का विस्तार:

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% विस्तारित:

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

— नंबर एक
स्रोत

1

तकनीकी रूप से, जावा charएक संख्यात्मक डेटा प्रकार है ।_

— कम्पास

@ कॉम आंतरिक रूप से यह है। लेकिन अगर मैं चार \u0030को एक स्ट्रिंग में परिवर्तित करता हूं, तो मुझे "0"नहीं मिलता है "48"।

— TheNumberOne

0

जावा - 257 वर्ण

जैसा कि हर कोई जानता है कि जावा की तुलना में गोल्फ के लिए कोई बेहतर भाषा नहीं है

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

यह असम्बद्ध समाधान है

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

— user902383
स्रोत

0

हास्केल - 98 94 बाइट्स

main=do
 a<-getLine
 b<-getLine
 let c d=last$takeWhile(\e->d/=(show$e-1))[0..]
 print$c a+c b

— globby
स्रोत

0

जावास्क्रिप्ट (ईएस 6), 55 66 59 *

 f=x=>{for(i=0;i+[]!=x;i++);return i};f((p=prompt)())+f(p())

* यह कुछ धारणाएँ बनाता है:

हम एक ES6 REPL वातावरण में हैं (उदा। फ़ायरफ़ॉक्स 33.1 ब्राउज़र कंसोल)
प्रदर्शन मायने नहीं रखता (गंभीरता से, '9999999999', '9999999999' को वापस लौटने में लगभग 20 मिनट लगे)
इंटेगर से स्ट्रिंग में परिवर्तित करने की अनुमति है
~~इनपुट को चर और बी में परिभाषित किया गया है, पूर्व:var a='123',b=321';~~ शीघ्र (+11) से इनपुट प्राप्त करने के लिए परिवर्तित।
इनपुट में कोई अग्रणी शून्य नहीं है।

— SLuck49
स्रोत

@ ऑप्टिमाइज़र मेला पर्याप्त, शीघ्र से खींचने के लिए अद्यतन

— SLuck49

आप उन वर्णों को बहुत नीचे लाने के लिए ES6 का उपयोग कर सकते हैं!

— ऑप्टिमाइज़र

मुझे लगता है कि 'या किसी भी संख्यात्मक डेटा प्रकार का उपयोग कर' का मतलब है कि आप भी छोरों के लिए उपयोग करने की अनुमति दी है।

— CSharpie

@CSharpie ओपी ने टिप्पणी की कि कोड में संख्या ठीक है

— SLuck49

0

पायथन 2.7, 196 137 चार्ट

संस्करण 2 (कोड के साथ शब्दकोश को छोटा करके छोटा):

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

पिछला संस्करण 1 (196 वर्ण):

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

जैसे

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

डिक्शनरी कीज़ स्ट्रिंग्स हैं, डिक्शनरी वैल्यूज़ में कोड को छोटा करने के लिए केवल नंबर स्थिरांक शामिल हैं, और गणना दो तारों को समतल करके और परिणामी लंबाई प्राप्त करने के लिए की जाती है, इसलिए मुझे उम्मीद है कि यह "उन्हें किलों में परिवर्तित नहीं करना" है।

पायथन स्मॉल-प्रिंट रूल-चीट संस्करण

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

ध्यान दें:

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

टाइप z एक कस्टम प्रकार है जिसे मैं परिभाषित करता हूं: निश्चित रूप से एक संख्यात्मक प्रकार नहीं है जो प्रश्नकर्ता परिभाषा का उपयोग करता है, लेकिन सीमित परिस्थितियों में उपयोगी होने के लिए संख्यात्मक प्रकार के करीब पर्याप्त व्यवहार करता है । इस कोड नमूने में टाइप z व्यवहार केवल आंशिक रूप से कार्यान्वित किया जाता है, और अगर CPython दुभाषिया z को लागू करने के लिए 'int' का उपयोग करता है , तो यह केवल एक कार्यान्वयन विवरण है और हाथ में समस्या से संबंधित नहीं है।

— TessellatingHeckler
स्रोत

बिना रूपांतरित हुए तार का योग

80836 विधानसभा ( 57 53 बाइट्स)

रूबी, 109 71

सेड, 359 बाइट्स (फैंटेसी फॉर्मेटिंग के बिना)

उत्पादन

रूबी - 485 432 265

CJam, 95 92 80 72 70 44 अक्षर

सी # - 128 108 104

GNU सेड, 266 बाइट्स

जावा 6 (181 अक्षर)

उपयोग करने का औचित्य eval

एपीएल (61)

पर्ल - 136 119 115 बाइट्स

जावा 7, स्कोर = 252

जावा - 257 वर्ण

हास्केल - 98 94 बाइट्स

जावास्क्रिप्ट (ईएस 6), 55 66 59 *

पायथन 2.7, 196 137 चार्ट

पायथन स्मॉल-प्रिंट रूल-चीट संस्करण

उपयोग करने का औचित्य `eval`