अनोखा सस्ता है

93

एक फ़ंक्शन या प्रोग्राम लिखें जो किसी दिए गए स्ट्रिंग की लागत निर्धारित करता है , जहां

  • प्रत्येक वर्ण की लागत स्ट्रिंग में इस बिंदु तक कितनी बार वर्ण हुई है, और की संख्या के बराबर होती है
  • स्ट्रिंग की लागत इसके पात्रों की लागत का योग है।

उदाहरण

के इनपुट के लिए abaacab, लागत की गणना निम्नानुसार की जाती है:

a b a a c a b
1   2 3   4    occurrence of a
  1         2  occurrence of b
        1      occurrence of c
1+1+2+3+1+4+2 = 14

इस प्रकार स्ट्रिंग के लिए लागत abaacab14 है।

नियम

  • आपके सबमिशन का स्कोर आपके कोड की लागत है जैसा कि ऊपर बताया गया है , यह आपका सबमिशन अपने ही सोर्स कोड पर चलता है, जिसमें कम स्कोर बेहतर होता है।
  • आपके सबमिशन को प्रिंट करने योग्य ASCII- वर्णों के साथ काम करना चाहिए, साथ ही आपके सबमिशन में उपयोग किए जाने वाले सभी वर्ण।
  • वर्ण केस संवेदी होते हैं, वह यह है कि aऔर Aविभिन्न पात्र हैं।

परीक्षण के मामलों

input -> output
"abaacab" -> 14
"Programming Puzzles & Code Golf" -> 47
"" -> 0
"       " -> 28
"abcdefg" -> 7
"aA" -> 2

लीडरबोर्ड

कोड स्निपेट दिखाएं

string  code-challenge 
— Laikoni
स्रोत
2
कैसे -nअंक झंडे के लिए जैसे कि पर्ल स्कोर के लिए गणना करते हैं? यह परंपरागत रूप से 1 बाइट के रूप में गिना जाता है क्योंकि मानक के बीच की दूरी 1 है perl -eऔर perl -neयह चुनौती है, लेकिन इस चुनौती के nलिए क्या डुप्लिकेट की गिनती के प्रयोजनों के लिए गिनती होगी ?
— वैल्यू इंक
2
@ValueInk हाँ, मुझे लगता है कि गिनती सबसे उचित nविकल्प है।
— लिकोनी
1
मैं वास्तव में इस चुनौती का दिमागी हल चाहता था।
— पीटर 1807
10
+1 आपके जमा करने के स्कोर के
— luizfzs
1
एक चरित्र की लागत के रूप में परिभाषित किया गया है how often this character has already occurred in the string, मैं शायद how many times the character has occurred up to this pointयह स्पष्ट करने के लिए बदल रहा हूं कि पहले उपयोग की लागत 1 है, न कि 0
— भूमिगत

जवाबों:

83

MATL , स्कोर 4

&=Rz

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

व्याख्या

'ABBA'उदाहरण के रूप में इनपुट पर विचार करें ।

&=   % Implicit input. Matrix of all equality comparisons
     % STACK: [1 0 0 1;
               0 1 1 0;
               0 1 1 0;
               1 0 0 1]
R    % Upper triangular part
     % STACK: [1 0 0 1;
               0 1 1 0;
               0 0 1 0;
               0 0 0 1]
z    % Number of nonzeros. Implicitly display
     % STACK: 6
— लुइस मेंडो
स्रोत
14
क्या आप एक रेखीय बीजगणित के प्रोफेसर हैं?
— मैजिक ऑक्टोपस Urn
4
@carusocomputing वास्तव में एक मोबाइल संचार प्रोफेसर हैं। मैट्रिसेस का उपयोग करने की मेरी प्रवृत्ति मैटलैब में प्रोग्रामिंग के वर्षों से आती है
— लुइस मेंडो
साफ! क्या उस क्षेत्र में मतलाब बड़ा है? मैंने वास्तव में जीएसएम या इसके जैसे कुछ भी नहीं देखा है।
— मैजिक ऑक्टोपस Urn
2
मैं इस शानदार समाधान पर आपकी सराहना करने के लिए इस समुदाय में शामिल हुआ!
— वॉब
1
@carusocomputing Matlab सामान्य रूप से इंजीनियरिंग में एक बहुत ही सामान्य उपकरण / भाषा है। यह संख्यात्मक अभिकलन में अच्छा है: रैखिक बीजगणित, सिग्नल प्रोसेसिंग और इसी तरह। और एक व्याख्या की गई भाषा होने के नाते इसका उपयोग करना बहुत आसान है
— लुइस मेंडो
17

पायथन , स्कोर 49

lambda S:sum(1+S.count(C)for[C]in	S)/2

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

इसके बाद एक टैब है in।

स्कोर टूटने:

  • 27 के लिए चार अद्वितीय आकर्षण
  • 8 दोहरे वर्णों के लिए +16: ()Camnou
  • 1 ट्रिप वाले चार के लिए +6: S
— XNOR
स्रोत
13
एक बाइट को बचाने के लिए एक जगह के बजाय एक टैब का उपयोग करें।
— mbomb007
1
@ mbomb007 बस एक ही विचार था :-)
— xnor
1
@ mbomb007 हैह, यह एक प्रतिभाशाली चाल है :-)
— ETHproductions
14
@ mbomb007 गोल्फ टैब्ड के अंदर सिर्फ वॉल्स बनाम स्पेस वॉर है
— एरिक द आउटगॉल्फ
2
मैं एक फॉर्म फ़ीड (जिसे पायथन सिंटैक्स में भी व्हाट्सएप की अनुमति है) का उपयोग करने का सुझाव देने जा रहा था, लेकिन आपके पास बदलने के लिए कोई और व्हाट्सएप नहीं है।
— user2357112
8

टी-एसक्यूएल, स्कोर 775 579! 580

declaRe @ char(876),@x int,@v int=0Select @=q+CHAR(9)from z X:seleCT @x=len(@),@=REPLACE(@,LEFT(@,1),''),@v+=(@x-LEN(@))*(@x-LEN(@)+1)/2IF LEN(@)>0GOTO X prINT @v-1

संपादित करें : एक जोड़े को गिरा दिया, थोड़ा सा संकुचित। @22 के बजाय 16 प्रतीकों के नीचे , यह अपने आप ही मेरे स्कोर को 117 अंकों से कम कर देता है!

अच्छी प्रतियोगिता, मुझे कुल चरित्र गणना के अलावा कुछ के लिए अनुकूलित करने की आवश्यकता पसंद है।

इनपुट हमारे मौजूदा नियमों के अनुसार , पूर्व-मौजूदा तालिका z में varchar फ़ील्ड q के माध्यम से है । इस इनपुट तालिका वाले डेटाबेस को केस-सेंसिटिव कॉलेशन के लिए सेट किया जाना चाहिए ।

प्रारूपित:

declaRe @ char(876), @x int, @v int=0
Select @=q+CHAR(9)from z
X:
    seleCT @x=len(@)
          ,@=REPLACE(@,LEFT(@,1),'')
          ,@v+=(@x-LEN(@))*(@x-LEN(@)+1)/2
IF LEN(@)>0 GOTO X
prINT @v-1

एसक्यूएल कीवर्ड केस संवेदी नहीं हैं, तो मैं मिश्रित केस इस्तेमाल किया डुप्लिकेट पत्र (की गिनती कम करने के लिए AAAA तुलना में एक बेहतर / कम स्कोर उत्पन्न aaaa )।

मुख्य लूप पहले चरित्र के सभी उदाहरणों को अलग करने से पहले और बाद में लंबाई की तुलना करता है। यह अंतर n * (n + 1) / 2 एक रनिंग टोटल में जोड़ा जाता है।

SQL LEN()फ़ंक्शन कष्टप्रद स्थानों की उपेक्षा करता है, इसलिए मुझे अंत में एक नियंत्रण वर्ण जोड़ना और 1 घटाना पड़ा।

संपादित करें : एक के आवरण को बदलकर 1 से घटाकर 2 अंक (उद्धरण चिह्नों के साथ मुद्दा) द्वारा मेरे खुद के स्कोर का एक गलत निर्धारण R। इसके अलावा, एक पूरी तरह से अलग रणनीति पर काम करते हुए, मैं इसे अपने स्वयं के उत्तर के रूप में पोस्ट करूंगा।

— BradC
स्रोत
3
पहले मुझे लगा कि आपका स्कोर था579! ≈ 8.22 x 10^1349
— इंजीनियर टोस्ट
8

सी (जीसीसी) , स्कोर:  113  103 100   96  91

उनकी युक्तियों के लिए @ugoren, @CalculatorFeline, @gastropner, @ l4m2, और @ JS1 को धन्यवाद।

g(char*s){int y[238]={};while(*s)*y-=--y[*s++];*y/=1;}

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

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

— Steadybox
स्रोत
3
सुझाव: चर के नामों कीवर्ड में उपयोग नहीं कर रहे हैं का उपयोग करें, जैसे z, x, c।
— कैलक्यूलेटरफल
@ कैलाकुलरफलाइन में charशामिल c...
— नील
3
इसके अलावा, आपको केवल 127 एलिमेंट एरे ( \x7fप्रिंट करने योग्य नहीं है) की जरूरत है और कृपया स्पष्टीकरण जोड़ें।
— कैलक्यूलेटरफ्लीन
1
पार्टी के लिए देर हो चुकी है, लेकिन यह 96 होना चाहिए:z;g(char*s){int y[238]={z=0};while(*s)z+=--y[*s++];z/=~0;}
— गैस्ट्रोपनर
1
g(char*s){int y[238]={};while(*s)*y+=--y[*s++];*y/=~0;}
— l4m2
7

जावास्क्रिप्ट (ईएस 6), स्कोर 81 78

@Arnauld की बदौलत 3 अंक की बचत की

s=>s.replace(d=/./g,z=>q+=d[z]=-~d[z],q=0)&&q

मेरा मूल स्कोर -81 पुनरावर्ती समाधान:

f=([c,...s],d={})=>c?(d[c]=-~d[c])+f(s,d):0
— ETHproductions
स्रोत
7

रेटिना , स्कोर 34

s(O`.
M&!`^|(?<=(.))\1*
.

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

व्याख्या

s(O`.

हम इनपुट में सभी वर्णों को क्रमबद्ध करके शुरू करते हैं ताकि समान वर्णों को एक ही रन में एक साथ समूहीकृत किया जा सके। s(सभी चरणों के लिए singleline मोड (यानी बनाता है को सक्रिय करता है .मैच linefeeds)।

M&!s`^|(?<=(.))\1*

लक्ष्य है n वर्णों की एक श्रृंखला को T n वर्ण ( n त्र त्रिकोणीय संख्या) में बदलना क्योंकि यह इस वर्ण की घटनाओं का स्कोर है। ऐसा करने के लिए, हम अतिव्यापी मिलान पाते हैं। विशेष रूप से, प्रत्येक के लिए मैं में [1, n] , हम शामिल करने के लिए जा रहे हैं i-1 मैच में पात्रों। ओवरलैपिंग फ्लैग के कारण हमें वो सभी मैच मिलते हैं &। यह हमें मैचों से n * (n-1) / 2 = T n-1 = T n - n अक्षर देता है। लेकिन मैच चरण इन्हें लाइनफीड्स के साथ जोड़ देगा, जो एन के लिए एन लाइनफीड हैंमैचों। केवल एक ही समस्या है। अंतिम मैच के बाद कोई लाइनफीड नहीं होगी, इसलिए आउटपुट में कुल वर्णों की संख्या हमारी ज़रूरत से कम है। हम इसे इनपुट की शुरुआत से मेल खाते हुए ठीक करते हैं, जो कम से कम एक अन्य मैच होने पर हमें एक अग्रणी लाइनफीड देता है।

.

अंत में, हम केवल यह गिनते हैं कि स्ट्रिंग में कितने वर्ण हैं।

— मार्टिन एंडर
स्रोत
6

हास्केल, स्कोर 52 51

f(a:b)=1+sum[1|c<-b,c==a]+f b;f _=0

वहाँ के बीच एक टैब है fऔर _।

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

खाली स्ट्रिंग का मान 0. है, स्ट्रिंग एस का मान, जहां aपहला चार है और bबाकी स्ट्रिंग 1 प्लस है और aइसके bअलावा बी के साथ एक पुनरावर्ती कॉल है।

— nimi
स्रोत
5

जे , स्कोर 16

1#.,@(*+/\"1)&=

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

व्याख्या

1#.,@(*+/\"1)&=
              =  Self-classify: bit matrix of equality between input
                 and its unique elements.
     (      )&   Apply verb in parentheses to it:
       +/\         running sums
          "1       of each row
      *            multiplied with original matrix.
                 This causes the i'th 1 on each row to be replaced by i.
   ,@            Flatten the resulting matrix
1#.              and interpret as a base-1 number, computing its sum.

राशि के 1#.बदले का उपयोग करने से +/@कुछ अंक बचते हैं , और एक के &बजाय @एक और संदर्भ को बचाने के लिए इसका इस्तेमाल किया जा सकता है । बार-बार 1मुझे एक अतिरिक्त बिंदु की लागत होती है, लेकिन मैं इससे छुटकारा नहीं पा रहा हूं।

— Zgarb
स्रोत
"बाद में" एक तिमाही का इंतजार कर रहा है
— कैलक्यूलेटर 1
2
@CalculatorFeline 10 घंटे बाद भी बाद में है। : पी
— ज़र्गब
चलो अब इसे एक सेक्विसिमिड बना देते हैं।
— कैलक्यूलेटरफ्लीन
मैं व्यक्तिगत रूप से कोड अनुभाग में एक सटीक बाइट गिनती को प्रतिबिंबित करने के लिए TIO उत्तरों के लिए इस प्रारूप का उपयोग करता हूं , शायद आप इसका उपयोग करना चाहते हैं
— Conor O'Brien
5

आर , स्कोर: 67 83 95 128

Giuseppe से शीर्ष सुझावों के लिए -61 धन्यवाद 

function(x,y=table(utf8ToInt(x)))y%*%{y+1}/2

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

स्ट्रिंग का उपयोग करके विभाजित किया जाता है utf8ToIntऔर प्रत्येक एएससीआई मूल्य को गिना जाता है table। परिणाम की गणना एक मैट्रिक्स गुणा करने के लिए की %*%जाती है, जो कि + 1 और अंत में आधा हो गया है।

— MickyT
स्रोत
के tableबजाय का उपयोग करें rle; आप के sortरूप में अच्छी तरह से छुटकारा पा सकते हैं (और आप [[1]]के परिणाम में अनुक्रमण करने के लिए नहीं है strsplit)
— Giuseppe
@Giuseppe बहुत बहुत धन्यवाद। मैंने टेबल के बारे में सोचा भी नहीं था, जल्द ही शामिल होगा।
— मिकटी
2
मुझे लगता है कि आप इसके बजाय एक अलग चर नाम का उपयोग करके कुछ बाइट्स बचा सकते हैं n(क्योंकि यह functionदो बार में है) और यह भी बदल रहा (n+1)है{n+1}
— Giuseppe
स्कोर: 67 । इस पर कुछ बदलाव से स्कोर को और कम करना संभव हो सकता है।
— ग्यूसेप
@Giuseppe ... मुझे इसे पढ़ना चाहिए था। वूप्स
— मिकी
4

पायथ , स्कोर 6

Isaacg के लिए 1 बाइट धन्यवाद।

+F/V._

परीक्षण सूट।

यह काम किस प्रकार करता है

+F/V._
+F/V._QQ  implicit input
  /V      vectorize count: for each element in the first argument,
                           count the number of occurrences of the
                           second argument:
    ._Q       all prefixes of input
       Q      input
+F        fold (reduce) on +, base case 0.
— लीक नन
स्रोत
s+0के रूप में ही है +F।
— इसहाक
अच्छा! मैं जो सबसे अच्छा कर सकता था वह usaShHGrScQ1 8Z16 के लिए है। क्या आप एक स्पष्टीकरण जोड़ सकते हैं?
— डिजिटल ट्रामा
1
@DigitalTrauma मैंने एक स्पष्टीकरण जोड़ा है।
— लीक नून
s/LQस्कोर 4 है, क्या यह उपयोग उन विशेषताओं को चुनौती देता है?
— डेव
4

जे , स्कोर: 14 12 11

$+/@,2!1#.=

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

— FrownyFrog
स्रोत
का चतुर प्रयोग $।
— कोल
अच्छा लगा। थोड़ा 11 बाइट भिन्नता:1#.2!1+1#.=
— जोना
@ जोनाह ग्लूफ़्स का पुन: उपयोग करने पर जुर्माना लगता है
— FrownyFrog
आह, वह हिस्सा याद किया।
— योना
4

सी, 60 बाइट्स, स्कोर 108 95

g(char*s){int y[256]={},z=0;while(*s)z-=--y[*s++];return z;}

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

आमतौर पर प्री-और पोस्ट-इन्क्रीमेंट ऑपरेटर कोड गोल्फ के लिए महान होते हैं, लेकिन वे वास्तव में इस चुनौती पर चोट करते हैं!

संपादित करें: सकारात्मक को जोड़ने के बजाय नकारात्मक गणना को घटाकर, मैंने स्कोर का एक पूरा गुच्छा बचाया। जगह for()के साथ while()के रूप में अच्छी तरह से एक अर्धविराम सफाया कर दिया।

— ErikF
स्रोत
3

C # (.NET कोर) , स्कोर ) (मेरा मतलब, 209)

b=>b.Distinct().Select(z=>{var w=b.Count(p=>p==z);return w*(w+1)/2;}).Sum()

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

स्कोर में निम्नलिखित शामिल हैं:

using System.Linq;
— चार्ली
स्रोत
मैं जानता हूँ कि यह एक समय हो गया है, लेकिन आप बदल सकते हैं return w*(w+1)/2करने के लिए return-~w*w/2(स्कोर 196)। संपादित करें: आप 149 के स्कोर के लिए मेरे जावा 8 उत्तर का एक पोर्ट बना सकते हैं : इसे ऑनलाइन आज़माएं। using System.Linq;b=>{int[]x=new int[256];return\nb.Select(z=>++x[z]).Sum();}
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन: मुझे आपका समाधान 111 के स्कोर तक मिल गया:b=>{var x=new int[256];return\nb.Sum(z=>++x[z]);}
— raznagul
यदि आप एक टैब में दूसरा स्थान बदलते हैं तो @raznagul ( * आधा साल पुरानी प्रतिक्रिया इनकमिंग * ) 109 । ;) इसे ऑनलाइन आज़माएं।
— केविन क्रूजेसेन
1
इंटरएक्टिव कंपाइलर के साथ @KevinCruijssen (आने वाला एक और आधा साल पुराना रिस्पांस), और मुझे लगता है कि यह कभी भी 48 से नीचे नहीं आएगा। मुझे यह अजीब लगता है कि कैसे अधिक गोल्फ वाले सी # उत्तर प्राप्त करते हैं, और अधिक पठनीय वे हमेशा बनने लगते हैं। इसे ऑनलाइन आज़माएं!
— कोई व्यक्ति
3

जेली , स्कोर 5

ĠJ€ẎS

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

-2 के लिए लीक नून को धन्यवाद (पहले उनके जवाब पर )

— आउटगोल्फर को एरिक करें
स्रोत
अहह मैंने इस सवाल को तेजी से नहीं देखा।
— लीक नयन
@LeakyNun ps आप हमेशा निंजा नहीं हैं, और न ही कोई है
— एरिक द आउटगेलर
वास्तव में? मुझे ऐसा नहीं लगता।
— कैलक्यूलेटरफल
स्कोर 5: ĠJ€ẎS
— लीके नन
@LeakyNun के रूप में वादा किया ... हाँ, क्रेडिट वहाँ है :)
— बाहर निकलना
3

पॉवरशेल, स्कोर 64

$z=@{}
$ARGS|% getE*|%{$u+=($Z.$_+=1)};$U

(स्कोर एक सिंगल लाइनफीड न्यूलाइन पर आधारित है, जो विंडोज मानक नहीं है, लेकिन पीएस में काम करता है)।

PS C:\> D:\unique-is-cheap.ps1 (gc D:\unique-is-cheap.ps1 -raw)
64
  • हैशटेबल काउंटर @{}
  • पत्रों के माध्यम से Iterate; $argsमापदंडों की एक सरणी है - इस मामले में इनपुट स्ट्रिंग इसे एकल आइटम सरणी बनाता है; |%आइटम पर एक फॉर्च्यूप लूप करता है, और स्ट्रिंग विधि getE*से मिलान करने के लिए शॉर्टकट का उपयोग करता है GetEnumerator()और स्ट्रिंग को एक चरित्र स्ट्रीम में बदलने के लिए कहता है।
  • |%पात्रों पर लूप करें और उनकी हैशटेबल प्रविष्टि बढ़ाएँ, इसे कुल रनिंग में जोड़ें। ($x+=1)कोष्ठक के साथ प्रपत्र दोनों चर को संशोधित करता है और उपयोग के लिए नया मान आउटपुट।
  • कुल चल रहा है आउटपुट।

(जब मैंने पहली बार इसे लिखा था, तो यह $c=@{};$t=0;[char[]]"$args"|%{$c[$_]++;$t+=$c[$_]};$t128 के स्कोर के साथ था , और ऐसा लगा कि यह बहुत कम नहीं होगा। इसे 64 पर हल करना काफी मनभावन है)।

— TessellatingHeckler
स्रोत
1
वृद्धि के साथ खिलवाड़ करके 61
— पीटी
59
— पीटी
3

जूलिया 0.6 , 45 बाइट्स, स्कोर: 77

MATL समाधान से प्रेरित:

f(w)=sum(UpperTriangular([z==j for z=w,j=w]))

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

एक कम सुंदर समाधान, मायने रखता है:

जूलिया 0.6 , स्कोर: 82

F(w)=sum(l->[l+1]l/2,count(x->x==i,w)for i=Set(w))

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

स्कोरिंग और टिप्स के लिए इशारा करने के लिए गुइसेपे को धन्यवाद। इन टिप्पणियों ने मुझे लोड करने में मदद की।

— niczky12
स्रोत
1
आपके सबमिशन का स्कोर आपके कोड की लागत है , जो मुझे लगता है कि 135 है।
— Giuseppe
1
मैं जूलिया को अच्छी तरह से नहीं जानता, लेकिन मुझे लगता है कि आप कुछ परिवर्तनीय नामों को स्विच करके और कोष्ठक का एक सेट हटाकर स्कोर को 110 तक कम कर सकते हैं । यदि एक एकल तत्व वेक्टर लौटने की अनुमति दी है, तो आप बदल सकते हैं (x+1)के साथ [x+1]आगे स्कोर कम करने के लिए।
— ग्यूसेप
आप दूसरे स्थान को टैब या नई-पंक्ति में बदलकर स्कोर बचा सकते हैं: स्कोर 104 । और @Giuseppe टिप का उपयोग [x+1]करने के बजाय (x+1)इसे 98 के स्कोर तक कम करता है ।
— केविन क्रूज़सेन
3

जावा 10, स्कोर: 149 138 137 134 133 130 103 102 101 100

( बाइट्स: 72 73 74 75 64 62 62 ) बाइट्स ऊपर जाती हैं, लेकिन स्कोर नीचे चला जाता है। : डी

x->{int j=0,q[]=new int[256];for(var    C:x)j+=++q[C];return
j;}

-28 स्कोर (और -11 बाइट्स) @Nevay को धन्यवाद ।
-1 स्कोर (और -2 बाइट्स) @ ओलिवियरग्रेयर के लिए धन्यवाद ।
जावा 8 को जावा 10 में परिवर्तित करके -1 स्कोर (और -1 बाइट)।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

x->{                     // Method with character-array parameter and integer return-type
  int j=0,               //  Result-integer, starting at 0
      q[]=new int[256];  //  Integer-array with 256 times 0
  for(var   C:x)         //  Loop over the characters of the input array
    j+=++q[C];           //   Raise the value in the array by 1,
                         //   and then add it to the result-integer
  return                 //  Return 
  j;}                    //         the result
— केविन क्रूज़सेन
स्रोत
1
~यदि आप उपयोग करते हैं j=0और return-j;(133) निकाल सकते हैं ।
— नेवई
1
103:x->{int[]q=new int[256];return\nx.chars().map(v->++q[v]).sum();}
— नेवे
1
@ नोवे 103 वास्तव में, जब मैं ( होते हैं ) और रिक्त स्थान के बजाय एक नई-लाइन और टैब jका उपयोग करता हूं । संपादित करें: हे, जब आपने यह टिप्पणी की है तो आपने सही संपादित किया है। :)ureturnu
— केविन क्रूज़सेन
3

एफ #, स्कोर 120 118

let j z=Seq.countBy id z|>Seq.sumBy(fun x->List.sum[0..snd x])

-2 केविन क्रूज़सेन को धन्यवाद !

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

stringएक इनपुट के रूप में लेता है । Seq.countByअपनी गिनती के साथ प्रत्येक विशिष्ट चरित्र को जोड़े ( idपहचान समारोह है) तो आप जैसे संग्रह के साथ समाप्त होते हैं'a' = 4, 'b' = 2 आदि के ।

Seq.sumByहर पत्र के लिए गिनती लेता है और से सभी नंबरों का योग 0है कि पत्र के लिए गिनती के लिए। तो अगर 'a' = 4संग्रह होगा 0, 1, 2, 3, 4जो एक साथ अभिव्यक्त किया गया है 10। फिर Seq.sumByउन सभी योगों को गाया।

— Ciaran_McCarthy
स्रोत
2
आप को बदलने के द्वारा 2 से अपने स्कोर को कम कर सकते हैं let qकरने के लिए let j, के बाद से qपहले से ही दोनों में प्रयोग किया जाता है Seq।
— केविन क्रूजसेन
2

APL (Dyalog) , स्कोर 15

+/1 1⍉+\∘.=⍨⍞

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

⍞ पाठ इनपुट प्राप्त करें

∘.=⍨ स्वयं के साथ समानता तालिका

+\ कुल योग

1 1⍉ विकर्ण (lit. दोनों आयामों को एक आयाम में समेटना)

+/ योग

— एडम
स्रोत
2

रेटिना , स्कोर 68 45 43

s`(.)(?<=((\1)|.)+)
$#3$*
1

इसे ऑनलाइन आज़माएं! लिंक स्कोर दिखाता है। संपादित करें: @MartinEnder को धन्यवाद, जिन्होंने लुकाहेड्स के बजाय ओवरलैपिंग मैचों का उपयोग करके 20 बाइट्स बचाए और चरणों को समूहीकृत करके तीन बाइट्स बनाए ताकि sध्वज को केवल एक बार लगाने की आवश्यकता हो। त्रिकोणीय संख्या की गणना करके आगे दो बाइट्स की बचत की, एक प्रकार की आवश्यकता से बचते हुए।

— नील
स्रोत
2

PHP , 45 बाइट्स, स्कोर 78

WHILE($x=ORD($argn[$v++]))$y+=$$x-=-1;echo$y;

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

PHP , 46 बाइट्स, स्कोर 79 बाइट्स

WHILE(~$xy=$argn[$vz++])$su-=-$$xy+=1;echo$su;

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

PHP , 56 बाइट्स, स्कोर 92

FOREAch(COUNT_CHARS($argn)as$z)WHILE($z)$y+=$z--;echo$y;

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

— जार्ग हुल्सरमैन
स्रोत
2

पर्ल 5 का स्कोर 91 83

-pविभाजन में पी की वजह से 2 को जोड़ने वाले ध्वज का उपयोग करता है ।

$x=$_;$b+=++$a{$_}for(split//,$x);$_=$b
— user1937198
स्रोत
PPCG में आपका स्वागत है!
— लैकोनी
1
आधार के रूप में आपके उत्तर का उपयोग करना और टिप्स पेज से कुछ तकनीकों को लागू करना, मैं आपका स्कोर 31 तक लाने में कामयाब रहा: इसे ऑनलाइन आज़माएं! । $` is automatically प्रिंट / / ed after each call so we can use that to store the score and / g` सभी वर्णों की एक सूची देता है $_, जो इससे सस्ता है split//।
— डोम हेस्टिंग्स
मुझे पता है कि यह एक पुरानी चुनौती है, लेकिन आप स्कोर को और भी अधिक काट सकते हैं: इसे ऑनलाइन आज़माएं!
— Xcali
2

ऑक्टेव , 39 बाइट्स, स्कोर 69

@(a)sum((b=hist(a,unique(1*a))).^2+b)/2

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

जबकि एक और ऑक्टेव उत्तर है, यह पूरी तरह से मेरा अपना है और एक अलग दृष्टिकोण है, साथ ही यह कम स्कोर करता है :)।

दृष्टिकोण पहले प्रत्येक अद्वितीय चरित्र की गिनती (बी) को खोजने के लिए उबलता है, जिसे हिस्टोग्राम फ़ंक्शन का उपयोग करके प्राप्त किया जाता है। फिर प्रत्येक तत्व के लिए हम 1 से b के योग की गणना करते हैं जो सूत्र का उपयोग करके किया जाता है (b*(b+1))/2। फिर व्यक्तिगत रकम सभी को अंतिम स्कोर के रूप में अभिव्यक्त किया जाता है।

परीक्षण में ऐसा लगता है कि कोष्ठक वास्तव में स्कोरिंग में महंगे हैं क्योंकि कई की आवश्यकता होती है। मैंने खुले / नज़दीकी कोष्ठक की संख्या को कम करने के लिए प्रश्नों को पुन: व्यवस्थित करके लगभग 88 के शुरुआती स्कोर से नीचे अनुकूलित किया है - इसलिए अब हम व्यक्तिगत रूप से करने के बजाय अंतिम कुल पर / 2 करते हैं, और साथ ही मैंने सूत्र को संशोधित किया है (b^2+b)/2जैसा कि कम कोष्ठक की आवश्यकता होती है।

— टॉम बढ़ई
स्रोत
1
दुर्भाग्य से यह खाली स्ट्रिंग पर विफल प्रतीत होता है:error: hist: subscript indices must be either positive integers less than 2^31 or logicals
— लैकोनी
2

कॉमन लिस्प, स्कोर 286 232 222

(loop with w =(fill(make-list 128)0)as z across(read)sum(incf(elt w(char-code z))))

कॉमन लिस्प के बिलिन ऑपरेटरों के वर्डी सिंटैक्स के कारण उच्च-मूल्यवान स्कोर।

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

अनगोल्ड कोड:

(loop with w = (fill (make-list 128) 0)  ; create a list to count characters
   as z across (read)                   ; for each character of input
   sum (incf (elt w (char-code z))))     ; increase count in list and sum
— रेंज़ो
स्रोत
2

गणितज्ञ, स्कोर ५४

Total[#(#+1)/2&@Counts@Characters@#]&

इनपुट

[ "Abcdefg"]

hftf के लिए धन्यवाद

— J42161217
स्रोत
Total[#(#+1)/2&@Counts@Characters@#]&स्कोर 54.
— hftf
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.