अंतर से कोई फर्क नहीं पड़ना चाहिए


40

आपकी कंपनी ने हाल ही में बेहद समर्पित sysadmins का एक नया गुच्छा किराए पर लिया है । उन्हें लगता है कि बस कंप्यूटर स्क्रीन देखना काफी सीमित है (मेरा मतलब है, 60 हर्ट्ज रिफ्रेश रेट सिर्फ इतना ही पर्याप्त नहीं है), इसलिए उन्होंने सीपीयू डेटा बस को एक डैक पर हुक कर दिया और एक स्पीकर पर सर्वर रूम के माध्यम से बजाया ताकि वे सुन सकें 20kHz को। एक समस्या: वे sysadmins हैं, इलेक्ट्रिकल इंजीनियर नहीं, और उनका स्पीकर सेटअप टूटता रहता है। उन्हें पता चला कि यह कोड में बाइट मानों में अचानक बदलाव के कारण होता है जो सॉफ्टवेयर इंजीनियर मेनफ्रेम पर संकलित करते हैं। Sysadmins अब एक छोटी प्रतियोगिता की मेजबानी कर रहे हैं, यह देखने के लिए कि कौन अपने कोड सेटअप के लिए सबसे कोमल है जो कोड बना सकता है।

चुनौती

आपका मिशन पसंद की भाषा में एक प्रोग्राम या फ़ंक्शन बनाना है जिसमें लगातार बाइट्स के बीच जितना संभव हो उतना कम अंतर होता है (गणना अनुभाग देखें)। इस कार्यक्रम में अपने स्वयं के स्कोर की गणना करने का कार्य होगा।

इनपुट

stdinयदि आप कोई फ़ंक्शन बना रहे हैं तो ASCII स्ट्रिंग या आपकी भाषा के निकटतम समकक्ष, या फ़ंक्शन इनपुट के रूप में। चूंकि आपके कार्यक्रम को अपने स्कोर की गणना करने के लिए इनपुट के रूप में खुद को लेना होगा, इसलिए यदि आपके पास कोई यूनिकोड है तो आपके प्रोग्राम को यूनिकोड का समर्थन करना चाहिए। अन्यथा, ASCII पर्याप्त है। इनपुट को कम से कम 2 बाइट्स लंबा माना जा सकता है।

गणना

ASCII मानक का उपयोग करके स्ट्रिंग के प्रत्येक वर्ण को संख्यात्मक रूप से परिवर्तित किया जाएगा। फिर, सभी वर्णों के बीच अंतर को पहले चुकता किया जाएगा और फिर सारांशित किया जाएगा । उदाहरण के लिए, स्ट्रिंग abdको एक स्कोर मिलेगा 1²+2²=5

उत्पादन

आउटपुट आपकी प्रविष्टि का शीर्षक होगा। इसका मतलब यह है कि यह #एक newline और a -(डैश) द्वारा पूर्व निर्धारित या संलग्न होना चाहिए । फिर, उसे आपकी प्रोग्रामिंग भाषा का नाम आउटपुट करना चाहिए, उसके बाद अल्पविराम, एक स्थान और फिर गणना के परिणाम का प्रतिनिधित्व करने वाला पूर्णांक। उदाहरण के लिए

#C++, 98

वैध आउटपुट होगा। आउटपुट को stdoutया आपकी भाषा को निकटतम समकक्ष, या आपके फ़ंक्शन के लिए वापसी मान के रूप में दिया जाना चाहिए ।

स्कोरिंग

आपके स्कोर की गणना आपके प्रोग्राम द्वारा इनपुट के रूप में प्रोग्राम के साथ की जाएगी।

संपादित करें: अब newlines को संभालना चाहिए, पहले के लिए क्षमा करें, दोस्तों

स्कोर गणना को सत्यापित करने के लिए यहां एक पाइथ स्क्रिप्ट है।


1
क्या प्रोग्राम को अपने कोड के अलावा किसी और चीज़ की व्याख्या करनी होगी? और सिर्फ स्पष्ट करने के लिए, दो लगातार समान वर्ण 0 का मान हैं?
डेनियल एम।


1
@bopjesvla ललित मनमाना तार, लेकिन आप उन्हें ब्रह्मांड में फिट होने में सक्षम मान सकते हैं। या आपके कंप्यूटर पर, उस बात के लिए।
सैनचाइज

11
Unary जीत में वैध उत्तर बनाने वाला पहला व्यक्ति !
ETHproductions

3
अब बहुत देर हो चुकी है, लेकिन यूनेरी-शैली के उत्तरों को रोकने का एक विकल्प बराबर वर्णों के बीच के अंतर को परिभाषित करना होगा। साथ ही तर्क को थोड़ा और दिलचस्प बना दिया होगा।
रेटो कोराडी

जवाबों:


19

सीजाम, 1051 827 643 569 545 407 327 279 235 233 229

''"','#'C'J'a'm',' qYew::-Yf#:+e#'''''''''"
f{-ci'(*''2*\}'^,40>"*/:N"-"][ZZ[\^__`bcdgimpstsz{}~~~"

उपरोक्त कार्यक्रम वास्तविक स्रोत कोड उत्पन्न करता है, जो 1,179,112 बाइट्स लंबा है।

परिक्षण

जावा दुभाषिया का उपयोग करते हुए , स्रोत कोड को उत्पन्न और परीक्षण किया जा सकता है:

$ alias cjam='java -jar cjam-0.6.5.jar'
$ cjam gen.cjam > diff.cjam
$ cksum diff.cjam 
896860245 1179112 diff.cjam
$ cjam diff.cjam < diff.cjam
#CJam, 229

वैकल्पिक संस्करण

36 अंकों की लागत पर - 265 के अंतिम स्कोर के लिए - हम स्रोत कोड को 99.92% कम कर सकते हैं:

'''()))))(''''(((('''())))))))))))))))))))))))))))('''()))))))))))))))))))))))))))))))))))('''())))))))))))))))))))))))))))))))))))))))))))))))))))))))))('''())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))('''()))))(''''((((((('())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))('())))))))))))))))))))))))))))))))))))))))))))))))))('())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))('())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))('()))))))))))))))))))('()))))))))))))))))))('())))))('())))))))))))))))))))))))))))))))))))))))))))))))))('()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(''(((('()))))))))))))))))))('())))('())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(''((((''''''''''''''''''()+,-.0123456789;<=>?@ABCDEFGHIJKLMOPQRSTUVWXYZ[\]][ZZ[\^__`bcdgimpstsz{}~~~

आप सीजेएम दुभाषिया में इस संस्करण को ऑनलाइन आज़मा सकते हैं ।

विचार

हम कोड निष्पादित करना चाहते हैं

'#'C'J'a'm',' qYew::-Yf#:+

स्कोर को यथासंभव कम रखना। इसे प्राप्त करने के लिए, हम उस स्ट्रिंग कैरेक्टर को कैरेक्टर द्वारा बनाने जा रहे हैं (रिजल्ट से पहले और बाद में कुछ ऑप्सन)।

सौभाग्य से, '(पुश वर्ण शाब्दिक), ((घटाना) और )(वृद्धि) लगातार ASCII वर्ण हैं, इसलिए मनमाने पात्रों को धकेलना अपेक्षाकृत सस्ता है।

  • ASCII वर्णों को बाद में 'धकेला जा सकता है '()…)(, जहां )कोड बिंदु पर निर्भर करता है।

    उदाहरण के लिए, के +रूप में धकेल दिया जा सकता है '())))(। के बीच की दूरी 'और (, और (और )1. अनुगामी है )(एक दूसरे को रद्द; उनका एकमात्र कार्य 'लगातार पात्रों के साथ निम्नलिखित (अगले चरित्र के अनुरूप) के लिए मार्ग प्रशस्त करना है ।

    इस तरह से धकेल दिए गए वर्ण 4 अंकों से स्कोर बढ़ाएंगे।

  • ASCII वर्णों को पहले 'धक्का दिया जा सकता है ''(…(, जहां (कोड बिंदु पर निर्भर करता है।

    उदाहरण के लिए, के #रूप में धकेल दिया जा सकता है ''((((। के बीच की दूरी 'और (1 है।

    इस तरह से धकेल दिए गए वर्ण 2 अंकों से बढ़ाएंगे।

  • ''(…(वास्तव में सभी ASCII पात्रों के लिए काम करता है , क्योंकि चरित्र 16 बिट चौड़ा है और चारों ओर लपेटता है। उदाहरण के लिए, 65,532 के बाद के +रूप में धकेल दिया जा सकता है ।''(

    इस तकनीक का उपयोग कोड के 1.2 मेगाबाइट संस्करण में किया जाता है।

  • चरित्र 'को धक्का दिया जा सकता है '', जिससे स्कोर अप्रभावित रहता है।

कोड

e# Push these characters on the stack: ','#'C'J'a'm',' qYew::-Yf#:+e#'''''''''

''
'()))))(
''
''((((
''
'())))))))))))))))))))))))))))(
''
'()))))))))))))))))))))))))))))))))))(
''
'())))))))))))))))))))))))))))))))))))))))))))))))))))))))))(
''
'())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(
''
'()))))(
''
''(((((((
'())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(
'())))))))))))))))))))))))))))))))))))))))))))))))))(
'())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(
'())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(
'()))))))))))))))))))(
'()))))))))))))))))))(
'())))))(
'())))))))))))))))))))))))))))))))))))))))))))))))))(
'()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(
''((((
'()))))))))))))))))))(
'())))(
'())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))(
''((((
''
''
''
''
''
''
''
''
''()

+                         e# Concatenate the two topmost single quotes.
,                         e# Push the length of the resulting string (2).
-.0123456789              e# Push that number.
;                         e# Discard it from the stack.
<                         e# Compare a single quote with 2. Pushes 0.
=                         e# Compare a single quote with 0. Pushes 0.
>                         e# Compare a single quote with 0. Pushes 1.
?                         e# Ternary if. Discards a single quote and 1.
@                         e# Rotate the remaining three single quotes.
ABCDEFGHIJKLMOPQRSTUVWXYZ e# Push 25 items on the stack.
[\]                       e# Swap the last two and wrap them in an array.

e# So far, we've pushed the elements of "','#'C'J'a'm',' qYew::-Yf#:+e#'''"
e# followed by the elements of [10 11 12 13 14 15 16 17 18 19 20]
e# and ["" "" "" 3.141592653589793 "" "" " " 0 0 0 -1 1 [3 2]].

]    e# Wrap the entire stack in an array.
[    e# Begin an array. Does nothing.
ZZ   e# Push 3 twice.
[    e# Begin an array. Does nothing.
\^   e# Swap both 3s and push the bitwise XOR. Pushes 0.
__   e# Push two copies.
`    e# Inspect the last copy. Pushes the string "0".
b    e# Convert "0" from base 0 to integer. Pushes 48.
cd   e# Cast 48 to Character, then Double. Pushes 48.0.
gi   e# Apply the sign function, then cast to integer. Pushes 1.
mp   e# Check 1 for primality. Pushes 0.
s    e# Cast the result to string. Pushes the string "0".

e# We now have three elements on the stack: an array, 0, and "0"

t    e# Set the element at index 0 of the array to the string "0".
s    e# Cast the array to string.

e# This pushes the string consisting of the characters
e#     0,'#'C'J'a'm',' qYew::-Yf#:+
e# and
e#     e#'''10111213141516171819203.141592653589793 000-1132
e#
e# When evaluated this does the following:
e#   0,                Push an empty array. Does not affect output.
e#   '#'C'J'a'm','     Push the characters of "#CJam, ".
e#   q                 Read all input from STDIN.
e#   Yew               Push the overlapping slices of length 2.
e#   ::-               Reduce each pair of characters to their difference.
e#   Yf#               Square each difference.
e#   :+                Add the results.
e#   e#…               Comment. Does nothing.

z    e# Zip. This wraps the string on the stack in an array.
{}~  e# Execute an empty block.
~    e# Unwrap the array.
~    e# Evaluate the string.

6
........... वाट
DLosc

यह लगभग ऐसा लगता है कि इस भाषा को इस सटीक चुनौती के लिए बनाया गया था। अच्छा!
डोमिनो

3
अरे नहीं। मुझे लगा कि मैंने आखिरकार एक चुनौती बनाई जो सीजेएम को नुकसान में डाल देगी क्योंकि यह अक्सर 'शुरुआती' प्रतीकों और 'देर' पत्रों का मिश्रण होता है। लेकिन नहीं, तुम दिखाओ और इसे फिर से बर्बाद कर दो ... चीयर्स!
Sanchises

7

हास्केल, 152827 95742 91196 83921 77447 71742

a=(.);_ZYXWVUTSRQPONMLKJIHGFEDCBA=("#Haskell, "++)`a`show`a`sum`a`fmap(^2)`a`(tail>>=zipWith(-))`a`fmap fromEnum`a`(""++)

उपयोग (नोट: "बचना होगा):

_ZYXWVUTSRQPONMLKJIHGFEDCBA   "a=(.);_ZYXWVUTSRQPONMLKJIHGFEDCBA=(\"#Haskell, \"++)`a`show`a`sum`a`fmap(^2)`a`(tail>>=zipWith(-))`a`fmap fromEnum`a`(\"\"++)"

"#Haskell, 71742"

मैं ""Haskell दुभाषिया के प्रकारों का पता लगाने में मदद करने के लिए इनपुट स्ट्रिंग के लिए खाली स्ट्रिंग प्रस्तुत करता हूं । इसके बिना टाइप इंफ़ेक्शन फेल हो जाता है, कोड बहुत अधिक पॉलीमॉर्फिक है। बाकी हमेशा की तरह व्यवसाय है: प्रत्येक चरित्र को अस्सी में मैप करें, पड़ोसी के अंतर, वर्ग, योग और भाषा के नाम की सूची बनाएं।


6

> <>, 30227

0&ii:0(?v:@-:*&+&20.
'#><>, '<;n&oooooo

गह, शीर्षक ने मेरा स्कोर दोगुना कर दिया; मेरे अपने कार्यक्रम के शब्दों में, n & oooooo! इसे बेहतर बनाने के लिए मुझे कुछ समय लगेगा। मुझे यह भी पता है कि यह स्कोर बंद हो सकता है क्योंकि मैं वास्तव में ऑनलाइन दुभाषिया पर नई सूची दर्ज नहीं कर सकता हूं और मुझे यकीन नहीं है कि आधिकारिक एक इनपुट स्टैक को आबाद करने का एक तरीका है।

किसी भी तरह से पूरी तरह से अनुकूलित नहीं है, लेकिन > <> में आदेशों के सापेक्ष निकटता (कम से कम ASCII वर्णों के संदर्भ में) का पूरा लाभ उठाता है। मैं आसानी से इनपुट के रूप में नई पंक्ति को प्रस्तुत नहीं कर सका, इसलिए मैंने पायथ स्कोर चेकर का उपयोग किया, लेकिन यह यादृच्छिक परीक्षण मामलों के एक समूह के लिए मेल खाता है जो मैंने उपयोग किए थे इसलिए यह उस संबंध में ठीक होना चाहिए।

यहाँ 30353 के स्कोर के साथ एक है (जो एक पंक्ति के बाद से सही होना चाहिए):

0&l1=66+*77++0.$:@-:*&+&10.' ,><>#'oooooo&n;

अच्छा,> <> में एक प्रतिस्पर्धी प्रविष्टि!
सेंचुरी

5

जावा, 66465 65506 62434

आश्चर्यजनक रूप से कम है। एक स्ट्रिंग के बजाय एक चार सरणी को स्वीकार करता है।

ABCD->{int A98=0,GFEDCBA=1,A987;for(;GFEDCBA<ABCD.length;A98=A98+(A987=ABCD[GFEDCBA]-ABCD[GFEDCBA++-1])*A987-0);return"#Java, "+A98;}

मैंने सबसे अच्छा चर नाम उत्पन्न करने के लिए एक कार्यक्रम का उपयोग किया।


आप एक कार्यक्रम में इसका उपयोग कैसे करेंगे? (मैं अभी तक जावा 8 सुविधाओं से पूरी तरह से परिचित नहीं हूं)
aditsu


ओह, तो आपको इसके लिए एक लक्ष्य कार्यात्मक इंटरफ़ेस को परिभाषित करना होगा ... बिल्कुल एक प्रथम श्रेणी की वस्तु नहीं।
aditsu

@aditsu आप फ़ंक्शन <char [], स्ट्रिंग> का उपयोग कर सकते हैं यदि आप चाहते थे।
TheNumberOne

ओह, मैं देख रहा हूँ ... ((Function<char[],String>) ABCD->{…}).apply(…)धन्यवाद। प्रकार के संदर्भ के बिना ये लंबोदर काफी अधूरे लगते हैं।
14

4

K5, 25478

"#K5, ",$+/1_{x*x}'-':

बहुत ही सरल उपाय। यह एक फ़ंक्शन है जो एक स्ट्रिंग के माध्यम से अपना इनपुट लेता है।


1
@ टिम्मीड फिक्स्ड !!
kirbyfan64sos 21

4

विंडोज पॉवरशेल ISE ​​होस्ट, 62978 63894 67960 77050

PARAM($4)($4.LENGTH-2)..0|foreach{$9=+$4[$_]-$4[$_+1];$0+=$9*$9};'#'+$HOST.NAME+', '+$0

संपादित करें - $Aचर से छुटकारा पाने के बजाय कुछ बिंदुओं को बचाया और इसके बजाय स्ट्रिंग के माध्यम से पीछे की ओर गिनती, और कुछ कीवर्ड को CAPS में परिवर्तित करके

Edit2 - के $($HOST.NAME)बजाय का उपयोग करके कुछ और बिंदुओं को बचायाPowerShell

Edit3 - चर नामों को स्वैप करके कुछ और बिंदुओं को सहेजा गया और परिवर्तित किया गया कि आउटपुट कैसे उत्पन्न होता है।

संख्याओं के साथ नामित चर का उपयोग करता है, क्योंकि वे "करीब" हैं $ताकि हमारा जुर्माना कम हो।

यह दिलचस्प है कि नियमित गोल्फिंग तकनीकों का उपयोग करें। उदाहरण के लिए, |%{$22534 है, जबकि |foreach{$केवल 8718 है।

यह संभवतः तकनीकों को बदलने के बिना इष्टतम के करीब है।


1
यह वही था जिसकी मैं उम्मीद कर रहा था। चीयर्स!
बजे

4

MATLAB, 19214 39748 39444 38785 37593

@(A9876543210)sprintf('#MATLAB, %d',diff(A9876543210)*diff(A9876543210'))

आगे की गिनती को कम करने के लिए लुइस मेंडो का धन्यवाद!

इनपुट चर नाम को बदलकर शोर की संख्या को कम करने के लिए नंबरऑन के लिए धन्यवाद!

यह कैसे काम करता है

  1. ansMATLAB में डिफ़ॉल्ट चर में संग्रहीत एक अनाम फ़ंक्शन की घोषणा करता है
  2. समारोह में संग्रहीत स्ट्रिंग में लेता है और स्ट्रिंग के A9876543210पड़ोसी मतभेदों के योग को प्रिंट करता है।
  3. diffएक सरणी में जोड़ीदार पड़ोसी अंतर पाता है और एक सरणी का उत्पादन करता है length(A9876543210)-1diffएक स्ट्रिंग सरणी पर उपयोग करने से, यह एक ऐसे doubleसरणी में जाता है जहां प्रत्येक वर्ण के ASCII कोड उत्पन्न होते हैं और लगातार जोड़े के अंतर दूसरे सरणी में परिणाम करते हैं।
  4. चुकता अंतरों का योग ज्ञात करने के लिए, आप बस इस अंतर सरणी के डॉट उत्पाद को स्वयं ट्रांसपोज़ड करते हैं। कर diff(A9876543210)'वास्तव में के साथ की तुलना में अधिक शोर का उत्पादन किया A9876543210.'(धन्यवाद लुइस मेंडू!)
  5. परिणाम स्क्रीन पर मुद्रित होता है।

अनाम कार्यों की अनुमति देने के लिए पीपीसीजी में यह सामान्य है। तो आप निकाल सकते हैंA=
लुइस मेंडो सेप

इसके अलावा, norm(diff(B))^2छोटा है
लुइस मेंडो सेप

@LuisMendo - कोशिश की है कि। यह वैज्ञानिक संकेतन को प्रिंट करता है और इसका सम्मान नहीं करता है %d
रायरेंग - मोनिका

आप Bएक चर नाम के रूप में क्यों उपयोग करते हैं ? A=@(A)...MATLAB मान्य है, क्योंकि Aस्कूप किया गया है।
सेंचुरी

3
A -> A9876543210
TheNumberOne

4

QBasic, 38140

SHAYY SYNTAX के लिए रास्ता

LINE INPUT A9876543210$:AAA=ASC(A9876543210$):WHILE A<LEN(A9876543210$):AA9876543210=AAA:A=1+A:AAA=ASC(MID$(A9876543210$,A)):A98765432100=A98765432100+(AA9876543210-AAA)*(AA9876543210-AAA):WEND:?"QBasic,";A98765432100

( QB64 के साथ परीक्षण किया गया ।)

यह एक पूर्ण प्रोग्राम है जो स्ट्रिंग इनपुट करता है और उत्तर को आउटपुट करता है। यहाँ केवल सीमा यह है कि प्रोग्राम मल्टीलाइन इनपुट नहीं ले LINE INPUTसकता है ( जब तक यह सिंगल लाइन है तब तक कुछ भी संभाल सकता है)।

Deobfuscated:

LINE INPUT line$
b=ASC(line$)
WHILE i<LEN(line$)
    a=b
    i=i+1
    b=ASC(MID$(line$,i))
    score=score+(a-b)*(a-b)
WEND
PRINT "#QBasic,"; score

आसानी से, ASCपहले चरित्र के ASCII मूल्य देने के लिए एक बहु-चरित्र स्ट्रिंग पास करना । इसके अलावा, संख्यात्मक रूप से, संख्यात्मक चर शून्य से आरंभिक होते हैं।


मैंने पहले कभी QBasic में कोडित नहीं किया है, इसलिए मुझे माफ कर दो अगर मैं गलत हूं, लेकिन क्या कुछ अतिरिक्त बिंदुओं को बचाने के लिए बड़े अक्षरों के साथ चर को बदलना संभव होगा?
ASCIIThenANSI

@DLosc आह, ठीक है। मैं वास्तविक प्रोग्राम के रूप में डिओबसकेटेड संस्करण पढ़ रहा था। : |
ASCIIThenANSI

3

अजगर 2, 91026

lambda A:"#Python 2, "+`sum((ord(A9876543210)-ord(A98765432100))**2for A9876543210,A98765432100 in zip(A,A[1:]))`

एक अनाम फ़ंक्शन को परिभाषित करता है जो एक स्ट्रिंग लेता है और स्कोर लौटाता है। इसे ऑनलाइन आज़माएं

इसमें से अधिकांश एक बहुत ही सीधा कार्यात्मक कार्यान्वयन है: पत्र जोड़े की एक सूची प्राप्त करने के लिए ज़िप Aकरें A[1:], फिर ordएक जनरेटर अभिव्यक्ति के साथ अपने एस, वर्ग और योग को घटाएं ।

गौर करें कि जनरेटर अभिव्यक्ति के अंदर दो चर ही कभी निम्न वर्णों द्वारा पीछा कर रहे हैं: ), ,, और अंतरिक्ष। इन तीनों में बहुत कम एएससीआईआई मूल्य हैं, इसलिए यह हमें प्रत्येक चर को कम-एएससीआईआई-मान के रूप में संभव के रूप में समाप्त करने के लिए प्रेरित करता है। सबसे कम वर्ण जो पायथन में एक चर को समाप्त कर सकता है 0। इसके अलावा, हर मौके पर हमें एक बड़ी छलांग को दो छोटे छलांगों में विभाजित करना होगा: स्कोर कम होगा: A0लागत 289, लेकिन A90केवल 145 है और A9876543210एक पैलेट्री 73 है।

(इस दृष्टिकोण ने लैम्ब्डा वैरिएबल की मदद नहीं कीA , शायद इसलिए कि यह [एक घटना के बाद है ।)


3

JSFuck, 144420642

इसे से बनाएँ:

t=arguments[0];n=0;for(u=1;u<t.length;++u)n+=(f=t.charCodeAt(u)-t.charCodeAt(u-1))*f;return'#JSFuck, '+n

इसे JSFuck.com के छोटे इनपुट बॉक्स में पेस्ट करें ताकि इसे JSFuck पर संकलित किया जा सके। परिणाम एक 112701 अक्षर लंबी स्क्रिप्ट है, इसलिए मैं इसे यहां नहीं डाल सकता। इस स्क्रिप्ट के अंतिम दो अक्षर कोष्ठक हैं, उनके बीच इनपुट डालें।

...)[+!+[]])('abd')

खुद का मूल्यांकन करने के लिए मेरे कंप्यूटर पर प्रोग्राम को लगभग 20 सेकंड लगते हैं।


व्याख्या

मुझे इस पर काम करने के लिए अधिक समय मिला, इसलिए मैं बैठ गया और चर नामों को अनुकूलित करने का प्रयास किया। यहाँ उनके प्राप्तांक के क्रम में चर नाम उपयोग करने लायक हैं।

u     ([][[]]+[])[+[]]                    17237
n     ([][[]]+[])[+!+[]]                  17437
f     (![]+[])[+[]]                       18041
t     (!![]+[])[+[]]                      18041
a     (![]+[])[+!+[]]                     18241
r     (!![]+[])[+!+[]]                    18241
d     ([][[]]+[])[!+[]+!+[]]              23405
N     (+[![]]+[])[+[]]                    23669
e     (!![]+[])[!+[]+!+[]+!+[]]           29217
i     ([![]]+[][[]])[+!+[]+[+[]]]         33581
l     (![]+[])[!+[]+!+[]]                 24209
s     (![]+[])[!+[]+!+[]+!+[]]            29217
uu    ([][[]]+[])[+[]]+([][[]]+[])[+[]]   36983

यहाँ जावास्क्रिप्ट है जिसका मैंने JSFuck में अनुवाद किया है:

score = 0;
for (u = 1; u < input.length; ++u)
  score += (difference = input.charCodeAt(u) - input.charCodeAt(u-1)) * difference;
return '#JSFuck, ' + score;

मैंने JSFuck.com के अनुवादक को करीब से देखा और यह पता लगाया कि इसका मूल्यांकन कार्य कैसे होता है। "एवल सोर्स" की जाँच के साथ, कोड एक स्व-निष्पादित JSFuck फ़ंक्शन बन जाएगा। इनपुट प्राप्त करने के लिए, हालांकि, हमें फ़ंक्शन के भीतर से तर्क [0] तक पहुंचने की आवश्यकता है। यह हमारे अंतिम जेएस कोड को लाता है ...

t=arguments[0];n=0;for(u=1;u<t.length;++u)n+=(f=t.charCodeAt(u)-t.charCodeAt(u-1))*f;return'#JSFuck, '+n

(यदि आप सोच रहे हैं कि मेरे पिछले संस्करण का स्कोर इससे कम क्यों था, तो यह इसलिए है क्योंकि यह एक JSFuck प्रोग्राम था जिसने एक स्ट्रिंग लौटाया था जिसे JS के रूप में मूल्यांकन करने की आवश्यकता थी। यही कारण है कि मैंने इसे पोस्ट में नहीं छोड़ा।


आपका absअनावश्यक है मुझे लगता है कि बस फर्क हो सकता है ... :)
Sanchises

6
मैंने स्कोर को भ्रामक पाया। आपको रिक्त स्थान हटा देना चाहिए। खासकर जब से आपके प्रोग्राम का आउटपुट होना चाहिए JSFuck, 102280181
mbomb007

@sanchises वास्तव में, मैं वास्तव में पहली बार वर्ग दो डालना भूल गया था, यही वजह है कि एक Math.abs था। ठीक कर देंगे।
डोमिनोज

@ mbomb007 ओह, ठीक है, तो भी ठीक कर देंगे।
डोमिनोज

3

सीजेम, 23663 19389 11547

"#CJam,"32A;clYew[]ULC;;;;::- 0$.*:+

इसे ऑनलाइन आज़माएं

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

अब तक मैंने जो सबसे बड़ा अंतर छोड़ा है , वह प्रारंभिक स्ट्रिंग में mऔर उसके बीच है ,। मुझे इससे छुटकारा पाने के लिए कुछ भी उचित नहीं मिला है। मुझे यकीन है कि वहाँ तरीके हैं। लेकिन अगर मैं इसे सीमा तक ले जाऊं, तो यह डेनिस के समाधान की तरह लग सकता है ...


3

JAVASCRIPT, 33911

$0123456789ABCDEFGHIJKLMNOPQRS=>/**/('#')+('JAVASCRIPT,')+(" ")+(($)/**/=0,($0123456789ABCDEFGHIJKLMNOPQRS[`split`]``[`map`]/**/(($$,$$$)/**/=>/**/($)/**/=Math[`pow`]/**/($0123456789ABCDEFGHIJKLMNOPQRS[T=`charCodeAt`]/**/($$$)+-($0123456789ABCDEFGHIJKLMNOPQRS[T]/**/(($$$)/**/>=6-5?/**/($$$)+-1:0.)),2)+($))),($))

यह अब तक की सबसे बड़ी अनुकूलन में से एक है जो मैंने एक कोड गोल्फ में किया है ...

"टिप्पणी स्पैम" सुझाव के लिए नील को सहारा = पी


मुझे लगता है कि आप /**/उचित स्थानों में सम्मिलित करके 5180 बचा सकते हैं।
नील

3

JAVASCRIPT, 31520

यह समाधान मेरे दूसरे से बहुत अधिक हास्यास्पद था , और इसलिए मुझे लगा कि यह इसका जवाब है।

A=>/**/(($)/**/=/**/(''),('000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000100000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000100000000000000000000000000000000000000001000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000100000000000000000000000000000000000000001000000000000000000000000000000000000000010000000000000000000000000000000000000000000100000000000000000000000000000000000000100000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000010000000000000000000000000000000100000000000000000000000000000000000000100000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000010/-,+*)(')/**/[`split`]``[`reduce`]/**/(($$,$$$,$$$$)/**/=>/**/($$$)/**/>7.-07?/**/(($)+=/**/((/**/String[`fromCharCode`]/**/)(($$$$)+-($$))),($$$$))/**/:/**/($$)),/**/eval/**/($))

यह 7306 वर्ण है, जिनमें से अधिकांश वास्तविक कार्यक्रम उस 0/1 स्ट्रिंग में एन्कोड किया गया है, और बाकी को केवल इसे डीकोड करना है। यह आवश्यक वर्ण मान प्राप्त करने के लिए प्रत्येक '1' के सूचकांक को पिछले '1' के सूचकांक से घटाकर काम करता है। तब यह वास्तविक कार्य में परिणामी स्ट्रिंग है, जो अनिवार्य रूप से समस्या को हल करने के लिए एक मानक-गोल्फ कार्यक्रम है (जो कि केवल लगभग 105 वर्ण हैं)।


2

आर, 68911 57183 53816 52224

एसटीडीआईएन से एक स्ट्रिंग लेता है और इसे कच्चे के माध्यम से पूर्णांक में परिवर्तित करता है। मुश्किल, वर्ग और परिणामी वेक्टर को समेटता है। परिणाम एक स्ट्रिंग के रूप में लौटाया जाता है। चर नाम टिप के लिए @nimi के लिए धन्यवाद।

'&&'=sum;'&&&'=diff;'&&&&'=as.integer;'&&&&&'=charToRaw;'&&&&&&'=readline;'&&&&&&&'=paste;'&&&&&&&'('#R,','&&'((A='&&&'('&&&&'('&&&&&'('&&&&&&'()))))*A))

@nimi इसके लिए धन्यवाद, 2 अटक गया, इसे छोटा रखने की कोशिश कर रहा था :)
मिकी

2

गणितज्ञ, 33552

A=ToExpression;A@ExportString[A@Characters@(**)"001000100010001101001101011000010111010001101000011001010110110101100001011101000110100101100011011000010010110000100000001000100011110000111110010101000110111101010011011101000111001001101001011011100110011101011011001000110010111000100011001001100100000001000100011010010110011001100110011001010111001001100101011011100110001101100101011100110100000001010100011011110100001101101000011000010111001001100001011000110111010001100101011100100100001101101111011001000110010101000000001000110101110100100110"(**),(**)"Bit"(**)]

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

"#Mathematica, "<>ToString[#.#&@Differences@ToCharacterCode@#]&

जो 37848 स्कोर करते हुए अपने आप ही एक मान्य उत्तर होता।

बाकि सब कुछ

A=ToExpression;A@ExportString[A@Characters@(**)"001..110"(**),(**)"Bit"(**)]

बस द्विआधारी स्ट्रिंग को डिकोड करता है और इसे गणितज्ञ कोड के रूप में व्याख्या करता है। ध्यान दें कि मैथेमेटिका की खाली टिप्पणी (**)बहुत "कम-शोर" है और वास्तव में "एस से शोर को हटाती है ।


2

जावा 8: 117170 100508 99062 98890

लैंबडा एक्सप्रेशन और वेरिएबल के इनलाइन असाइनमेंट की मदद से इस कोड को थोड़ा छोटा किया जा सकता है।

A->{int B=0,D=0,E=0;char[] C=A.toCharArray();for(;D<C.length-1;)B+=(E=C[D]-C[++D])*E;return"#java, "+B;}

ए -> ए 9876543210; बी -> $ 0123456; सी -> ए; डी -> एए; E -> $ 0123456789
TheNumberOne 12

2

जावा, 129300 128400 110930 106581 105101

B->{int A=0,C=A;char[]Z=B.toCharArray();for(;++C<Z.length;A=A+(Z[C]-Z[C-1])*(Z[C]-Z[C-1]));return\"#Java, \"+A;}

इस चुनौती ने वास्तव में मुझे सबसे छोटे समाधान खोजने की तुलना में पात्रों के उपयोग और अनुकूलन के बारे में गहराई से सोचने का मौका दिया। मैं नंबर नीचे लाने के लिए काम करता रहूंगा।

यह एक लैम्बडा फ़ंक्शन है, जिसमें Bस्ट्रिंग फ़ंक्शन का प्रतिनिधित्व करता है। "इसे स्ट्रिंग के रूप में पास करते समय उद्धरणों ( ) से बचना न भूलें ।


2

पायथ, 16391

++C38828542027820dsm^-ChdCed2,Vztz

यहां उपयोग किए जाने वाले नोट का एकमात्र ट्रिक बेस- 256 एनकोडिंग है #Pyth,, जिसकी लागत स्ट्रिंग से बहुत कम है।

++C38828542027820dsm^-ChdCed2,Vztz    Implicit: d=' ', z=input()
                             ,Vztz    Pair each char in the input with its neighbour
                   m                  Map d in the above to:
                      Chd               ASCII code of 1st char
                         Ced            ASCII code of 2nd char
                     -                  Difference between the two
                    ^       2           Squared
                  s                   Take the sum
  C38828542027820                     '#Pyth,'
++               d                    '#Pyth,' + ' ' + result, implicit print

2

एम, 47033 52798

A9876543210(A9876543210) F AA9876543210=2:1:$L(A9876543210) S AAA9876543210=$A($E(A9876543210,AA9876543210-1))-$A($E(A9876543210,AA9876543210))**2+AAA9876543210
    Q "#M, "_AAA9876543210

इसका उपयोग करने के लिए, हमें उद्धरण और "व्हाट्सएप" वर्णों से बचना होगा (जो MUMPS में महत्वपूर्ण हैं!) जैसे:

>$$A9876543210^MYROUTINE("A9876543210(A9876543210)"_$C(9)_"F AA9876543210=2:1:$L(A9876543210) S AAA9876543210=$A($E(A9876543210,AA9876543210-1))-$A($E(A9876543210,AA9876543210))**2+AAA9876543210"_$C(10,9)_"Q ""#M, ""_AAA9876543210")
#M, 47033

ध्यान दें कि "M" "MUMPS" का एक वैकल्पिक नाम है - चिकित्सकों के बीच असहमति है जिसके बारे में एक सही है। स्वाभाविक रूप से, मैंने यहां छोटा विकल्प चुना है।


क्या आपको AAAA इनिशियलाइज़ नहीं करना चाहिए?
एसएसएच

ऑपरेटर प्राथमिकताओं की कमी के कारण, आप एस एएए = $ ए ($ ई (ए, एए -1)) - $ ए ($ ई (ए, एए)) ** 2 + एएए - एक कम दे सकते हैं स्कोर ...
एसएसएच

@SSH मैं फ़ंक्शन को कॉल करने से पहले एक साफ प्रतीक तालिका मान रहा हूं (इसलिए मुझे NEWसामान नहीं करना है )। इसलिए जब मैं AAAA(अब AAA9876543210) अंकगणित करना शुरू करता हूं , तो यह करने के लिए मजबूर हो जाता है 0(हो सकता है कि यह सिर्फ कैच कार्यान्वयन विवरण हो? मेरे पास जीटीएम स्थापित नहीं है)। ऑपरेटर प्राथमिकताओं पर अच्छी कॉल बात; मुझे हमेशा विशुद्ध रूप से बाएं से दाएं संचालन के बारे में सोचना मुश्किल लगता है। (मैं यह भी भूल गया कि एम का एक एक्सप्रेशनरी ऑपरेटर है - यह कुछ ऐसा नहीं है जो आप
सीआरयूडी

अच्छा! बाएं-से-सही निष्पादन के कारण, आपको ** 2 से पहले कोष्ठक की आवश्यकता नहीं है
SSH

@SSH धन्यवाद, पता नहीं कैसे वहाँ पहुँच गए। जिस संस्करण को मैंने वास्तव में मापा था, वह नहीं है, इसलिए स्कोर अभी भी वही है।
सेंसहिन

1

रूबी, 118402

puts "#Ruby, #{a=0;aa=nil;File.read(ARGV[0]).each_byte{|aaa| aa||=aaa;a+=(aaa-aa)**2;aa=aaa};a}"

यह कमांड लाइन के माध्यम से एक फाइल में पढ़ता है, जैसे कि ruby diff.rb /path/to/file। इसमें सुधार करने के लिए जगह है, और अभी मैं कुछ काम कर रहा हूं।


1

सी ++ 166345

void n(){int b=0,c,d;string a;cin >>a;for(c=1;c<a.length();++c){d=(a[c]-a[c-1]);b+=d*d;}cout<<"#C++, "<<b;}

1

पर्ल, 93556

chomp($A=<>);$AAA=$AAAA=0;foreach$AAAAA(split'',$A){$AA=ord($AAAAA);$AAA+=($AAAA-$AA)**2 if($AAAA!=0);$AAAA=$AA}print'#Perl, '.$AAA

मैं इसे कुछ और नीचे काटने की कोशिश करूँगा।

यह पता चलता है कि घुंघराले ब्रेसिज़ ( {और }, एएससीआईआई 123 और 125) और अंडरस्कोर ( _एएससीआईआई 95) बहुत महंगे हैं क्योंकि अन्य सभी वर्ण 30-70 के आसपास हैं, यही कारण है कि मैंने ifजिस तरह से किया, और मैंने इसे स्वरूपित किया क्यों मैं $AAAAAपर्ल के प्रिय के बजाय उपयोग कर रहा हूं $_

अफसोस की बात है, उनमें प्रतीकों वाले सभी चर केवल-पढ़े जाते हैं, इसलिए मैं जैसे $#और के संयोजन का लाभ नहीं उठा सकता $$


1

एफ #, 136718 130303

let(A)=Seq.map;
(stdout.Write(Seq.sum(A(fun(AA)->AA*AA)(A((<||)(-))(((Seq.pairwise(A(int)(stdin.ReadToEnd())))))))))

जहां एक के \nबाद एक है ;


1

पोसिक्स शेल, 172026

{ while IFS= read -N 1 A; do A1=$(printf %d \'"$A");test "$A1" -eq 0 && break;case $A11 in "")A111=0;;*)A111=$((A1-A11));;esac;A11="$A1";A1111=$((A111**2+A1111));done;echo "# POSIX Shell, $A1111";}

बहुत बुरा मुझे पाइथ चेकर (178386) के समान परिणाम नहीं मिल सकता है ...


1. "शेल" एक प्रोग्रामिंग भाषा नहीं है। यह बैश जैसा दिखता है। 2. आप बस STDIN से पढ़ सकते हैं। स्रोत कोड को स्वयं पढ़ने की आवश्यकता नहीं है।
डेनिस

@ डेनिस धन्यवाद, संपादित ... हालांकि मैं एक ही परिणाम प्राप्त नहीं कर सकता, शायद अभी भी एक बग है (कम से कम एक बार मुझे एक ही परिणाम मिला लेकिन "संपीड़ित" संस्करण में नहीं) ...
एलोइस महदाल

1

लुआ, 171078 117896

golfed:

A=string AA=A.sub AAA=io.read()AAAA=#AAA AAA=AAA..AA(AAA,AAAA,AAAA)AAAAA=0 AAAAAA=A.byte for AAAAAAA=1,AAAA do AAAAAAAA=AAAAAA(AA(AAA,AAAAAAA,AAAAAAA))-AAAAAA(AA(AAA,AAAAAAA+1,AAAAAAA+1))AAAAA=AAAAA+AAAAAAAA*AAAAAAAA end print(AAAAA)

Ungolfed:

A=string 
AA=A.sub 
AAA=io.read()
AAAA=#AAA 
AAA=AAA..AA(AAA,AAAA,AAAA)
AAAAA=0 
AAAAAA=A.byte 
for AAAAAAA=1,AAAA do 
    AAAAAAAA=AAAAAA(AA(AAA,AAAAAAA,AAAAAAA))-AAAAAA(AA(AAA,AAAAAAA+1,AAAAAAA+1))
    AAAAA=AAAAA+AAAAAAAA*AAAAAAAA 
end 

print(AAAAA)

0

सी ++, 49031

C ++ मैक्रो जो एक सी-स्ट्रिंग लेता है और मानक आउटपुट के लिए परिणाम लिखता है

<::>(auto(A))<%long(AAA)=0,AA=A<:0:>;while(*++A)<%AAA+=(*A-AA)*(*A-AA);AA=A<:0:>;%>cout<<"#C++, "<<AAA;%>

इसे ऑनलाइन आज़माएं!


-3

सी ++, 5

    #include <iostream>
    #include <string>
    #include <cmath>
    using namespace std;

    void convertToASCII(string letter)
    {
        int count = 0;
        int ans = 0;
        int *diff = new int[]; //dynamic array

        for(int i=0; i<letter.length(); i++)
        {
            char x = letter[i]; //letter.at(i);

            if(i!=0){
                diff[i-1] = int(x)- int(letter[i-1]);
                count++;
            }
        }

        for(int j=0; j<count; j++){
            ans += pow(diff[j], 2.0);
        }

        cout << "#C++, " << ans << endl;
    }

    int main()
    {
        string plainText;
        cout << "Enter text: ";
        getline(cin, plainText);
        convertToASCII(plainText);
        system ("pause");
        return 0;
    }

7
प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यह एक मान्य उत्तर है, लेकिन इस चुनौती के लिए आपका स्कोर कार्यक्रम के माध्यम से आपके कार्यक्रम के पाठ का परिणाम होना चाहिए। आपको उस स्कोर को जितना संभव हो उतना कम से कम करने की कोशिश करनी चाहिए। इन पृष्ठों पर युक्तियों के माध्यम से देखने का प्रयास करें कि आप अपने कोड को कैसे छोटा कर सकते हैं और अपना स्कोर कम कर सकते हैं।
ETHproductions 12
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.