... और मेरे कोड दोस्तों के लिए असली गोल्फ।

यह एक साल पुरानी एक्सकेसीडी कॉमिक पर आधारित एक चुनौती है जिसमें एक अलग पैटर्न का अनुसरण करते हुए ज्यादातर टोस्ट (कॉमिक में पहले की पैरोडी) शामिल हैं, लेकिन कुछ मामूली बदलाव के साथ।

आपका कार्य एक प्रोग्राम (या फ़ंक्शन) लिखना है जो कॉमिक से किसी भी टोस्ट का पहला आधा हिस्सा लेता है (सब कुछ और सहित friends) इनपुट के रूप में (स्टड या एक फ़ंक्शन तर्क के माध्यम से) और आउटपुट (या रिटर्न) सटीक पाठ दूसरा आधा। आपको अमान्य इनपुट, मानक कमियां लागू करने की आवश्यकता नहीं है, बाइट्स जीत में सबसे छोटा कोड है।

उदाहरण

उन लोगों की मदद करने के लिए जो कहीं और से टोस्टों की नकल नहीं करना चाहते हैं, यहाँ उन सभी को इनपुट और आउटपुट में अलग किया गया है।

Input: Champagne for my real friends
Output: and real pain for my sham friends!

Input: Pseudopods for my real friends
Output: and real pods for my pseudo-friends!

Input: Petticoats for my real friends
Output: and real coats for my petty friends.

Input: Loosestrife for my real friends
Output: and real strife for my loose friends!

Input: Ladybugs for my real friends
Output: and real bugs for my lady friends!

Input: Single-payer for my real friends
Output: and RealPlayer for my single friends.

Input: Tumbleweeds for my real friends
Output: and real weed for my Tumblr friends!

Input: Fauxhawks for my real friends
Output: and real hawks for my faux friends!

Input: Platonic solids for my real friends
Output: and real solids for my platonic friends!

code-golf string kolmogorov-complexity

— ivzem
स्रोत

मुझे लगता है कि आपके पास Single-payer(के बजाय Single-player) एक टाइपो है ।

— केविन क्रूज़सेन

4

केविन: नहीं। यह वास्तव में है Single-payer।

— ivzem

@ केविनक्रूजसेन - यह एक टाइपो हो सकता है, लेकिन अगर ऐसा है तो यह रान्डेल @ एक्सकेसीडी का है, आइवीजेम का नहीं। Explain xkcd पर इसकी चर्चा है । इसके अलावा, ivzem - जैसे ही मैंने HNQ सूची में शीर्षक देखा, मुझे यकीन था कि आप उस कॉमिक का संदर्भ दे रहे थे। बहुत बढ़िया!

— बोबसन

18

रेटिना , 119 बाइट्स

पिछले संस्करण ने "प्लेटोनिक ठोस" में स्थान का सही प्रबंधन नहीं किया, यह एक काम करता है और कम होता है :)

ew
rw
eds
ed
(\w+) ?([^oatr ]\w{3}.+)real
and real $2$1
C
S
gne
in
o 
o-
ti
ty
T`TL`Tl
p\w+y.+
$&.
s$
s!
real -p
RealPl

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

यह प्रतिस्थापनों की एक श्रृंखला के माध्यम से इनपुट को आउटपुट में बदल देता है।

सबसे दिलचस्प हिस्सा यह प्रतिस्थापन है (रेगेक्स गोल्फ का प्रकार):

(\w+) ?([^oatr ]\w{3}.+)real
and real $2$1

जो लगभग सभी काम करता है, पहले शब्द को विभाजित करके, उसके टुकड़ों को सही स्थानों पर रखकर, अतिरिक्त स्थान हटाकर, आउटपुट की संरचना का निर्माण करता है। "Tumbleweeds" परीक्षण मामले पर सही ढंग से काम करने के लिए यह पिछले प्रतिस्थापन "eds" -> "ed" पर निर्भर करता है।

बाकी ज्यादातर विशेष मामलों से निपटने वाले प्रतिस्थापनों से बना है। अन्य रोचक भाग हैं:

T`TL`Tl

यह "T" (Tumblr के लिए) को छोड़कर सब कुछ बदल जाता है।

p\w+y.+
$&.
s$
s!

यह एक जगह है " प्रत्येक वाक्य के अंत में "y" के साथ एक शब्द होता है, जो "पी" ("क्षुद्र" और "भुगतानकर्ता" व्यवहार में कुछ अक्षर) के बाद होता है। फिर एक "स्थानों!" एक "एस" (सभी अन्य) के साथ समाप्त होने वाले सभी वाक्यों के अंत में।

— सिंह
स्रोत

इसके बाद एक अतिरिक्त स्थान प्रिंट करता है platonic। सुझाया गया फिक्स: TIO (+5 बाइट्स)

— गणित रद्दी

1

@math_junkie धन्यवाद, मैंने एक नया संस्करण अपलोड किया है जो रिक्त स्थान के साथ समस्या को ठीक करता है और और भी छोटा होता है :)

— लियो

10

पायथन 2, 291 269 293 255 247 बाइट्स

Erik the Outgolfer22 बाइट बचाने के लिए धन्यवाद !

.इसके बजाय कुछ आउटपुट को समाप्त करने के लिए 768 बाइट्स!

lambda x:'and '+['real '+'pain%ssham ,pods%spseudo-,coats%spetty ,strife%sloose ,bugs%slady ,weed%sTumblr ,hawks%sfaux ,solids%splatonic '.split(',')['noarsekc'.find(x[7])],'RealPlayer%ssingle ']['-'in x]%' for my '+x[-7:]+'!.'['-'in x or'tt'in x]

चीजों को शुरू करने का सरल उपाय। इनपुट के आठवें अक्षर की जाँच करता है, जैसा कि टिप्पणियों में सुझाया गया है, और ~~एक शब्दकोश~~ में इसी आउटपुट को देखता है ।

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

— गणित के दीवाने
स्रोत

आप भूल गए होंगे Single-payer for my real friends...

— मैथ्यू रोडिक

@ मैथियोरोडिक नहीं, वह काफी इरादतन है। RealPlayerएक विशेष मामला है

— गणित नशेड़ी

उफ़, क्षमा करें, बहुत जल्दी पढ़ें।

— मैथ्यू रोडिक

6

एसओजीएल , 143 बाइट्स

_╔x⅜²‘,8WWAa"⅞+1Tλ²⅞ƨ◄…χŗbdŗu8ņ∑Ι⅓I‼hzΔμō┘═q‼xΘ▼²ηpG⅔─┌¡↕+wd÷[≈┐α┌ļ○(‚δΦEΤα{‚φ▒k׀:╚s&⅛↑»‘ |Θwθ1w"ρ└⁸‘S∆∫⁴‘a1>*+oo"¤Ε○Φr‘o2w _@ŗo"æn‘o"χ}49⁶‘aWT

यह इस स्ट्रिंग को मुख्य भाग के रूप में उपयोग करता है। "|" स्प्लिटर्स हैं और "_" स्पेस प्लेसहोल्डर हैं इसलिए स्प्लिट सही तरीके से काम करेगा।

RealPlayer single_|weed Tumblr_|strife loose_|bugs lady_|pods pseudo-|pain sham_|solids platonic_|coats petty_|hawks faux_

इनपुट उदाहरण: "मेरे वास्तविक दोस्तों के लिए प्लैटोनिक ठोस" स्पष्टीकरण:

..‘,8WWAa"..‘ |Θwθ1w"..‘S∆∫⁴‘a1>*+oo"..‘o2w _@ŗo"..‘o"..‘aWT  strings shortened
..‘                                                           push "personcake" (the indexing string) ["personcake"]
    8W                                                        get the 8-th char                       
   ,                                                           from the input                         ["personcake", "c"]
      W                                                       get its in "personcake" (1-indexed)     [7]
       Aa                                                     save on variable A                      [7]
         "..‘                                                 push the long string                    [7, "RealPlayer...faux_"]
              |Θ                                              split on "|"                            [7, ["RealPlayer single_", ..., "hawks faux_"]]
                w                                             get the Ath item of the array           [["..."], "solids platonic_"]
                 θ                                            split on spaces                         [["..."], ["solids", "platonic_"]]
                  1w                                          get the 1st item                        [["..."], ["solids", "platonic_"], "solids"]
                    "..‘                                      push "and "                             [["..."], ["solids", "platonic_"], "solids", "and "]
                        S∆∫⁴‘                                 push "real "                            [["..."], ["solids", "platonic_"], "solids", "and ", "real "]
                             a1>*                             multiply by A(index) > 1                [["..."], ["solids", "platonic_"], "solids", "and ", "real "]
                                 +                            join together                           [["..."], ["solids", "platonic_"], "solids", "and real "]
                                  o                           output                                  [["..."], ["solids", "platonic_"], "solids"]
                                   o                          output (the 1st item of the array)      [["..."], ["solids", "platonic_"]]
                                    "..‘o                     output " for my "                       [["..."], ["solids", "platonic_"]]
                                         2w                   get the 2nd item of the array           [["..."], ["solids", "platonic_"], "platonic_"]
                                            _@ŗ               replace "_" with " "                    [["..."], ["solids", "platonic_"], "platonic "]
                                               o              output that                             [["..."], ["solids", "platonic_"]]
                                                "..‘o         output "friends"                        [["..."], ["solids", "platonic_"]]
                                                     "..‘     push ".!!!!!!.!"                        [["..."], ["solids", "platonic_"], ".!!!!!!.!"]
                                                         aW   get the Ath item                        [["..."], ["solids", "platonic_"], "!"]
                                                           T  output, disabling implicit output       [["..."], ["solids", "platonic_"]]

— dzaima
स्रोत

6

पायथन 3 , 788 , 403 , 359 396 बाइट्स

नवीनतम संस्करण

यह अब मेरा पांचवा प्रयास है। मैंने अपने मूल कार्यक्रम के आधे आकार का प्रबंधन कर लिया है। इसमें अब लापता "-" शामिल है और मेरा मानना है कि एक पूर्ण समाधान है। फिर भी मुझे भारी पक्ष पर संदेह है; लेकिन लक्ष्य के बहुत करीब। मुझे बहुत मदद मिली है । सभी उपयोगी मार्गदर्शन के लिए धन्यवाद।

s=input()
x=0
l= "Ch,pain,Sham,Ps,pods,psuedo-,Pe,coats,petty,Lo,strife,loose,La,bugs,lady,Si,RealPlayer,single,Tu,weed,Tumblr,Fa,hawks,faux,Pl,solids,platonic".split(",")
a,b,c,d,e,f,g,h = " and real","for my","friends",".!","print(a,l[p+1],b,l[p+2]",",c+d[0])","+c+d[1])",",c+d[1])"
for p in range(0,27,3):
 x+=1
 if s[:2] == l[p]:
  if x == 2: eval(e+g)
  else: eval(e+f if x in(3,6) else e+h)

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

मूल पोस्टिंग

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

phraseList= [   ("Champagne","pain","Sham"), 
                ("Psudeopods","pods","psuedo-"), 
                ("Petticoats","coats","petty"),
                ("Loosestrife","strife","loose"),
                ("Ladybugs","bugs","lady"),
                ("Single-payer","coats","petty"),
                ("Petticoats","RealPlayer","single"),
                ("Tumbleweeds","weed","Tumblr"),
                ("Fauxhawks","hawks","faux"),
                ("Platonic solids","real solids","platonic")
                ]

for phrase in phraseList:
    print("Input: ",phrase[0], "for my real friends.")
    if "-" in phrase[2]:
        print("Output: and real", phrase[1], "for my", phrase[2]+ "friends!")
    else:
        print("Output: and real", phrase[1], "for my", phrase[2], "friends!")

— ब्रायन
स्रोत

3

सहायता केंद्र से : चुनौतियों के सभी समाधान चाहिए: [...] उपयोग में जीतने के मानदंडों के लिए एक गंभीर दावेदार बनें। उदाहरण के लिए, एक कोड गोल्फ प्रतियोगिता में प्रवेश की आवश्यकता होती है, और एक गति प्रतियोगिता में प्रवेश करने के लिए कुछ प्रयास करना चाहिए।

— को एग्री आउटलफर

1

नमस्कार और साइट पर आपका स्वागत है। यह एक कोड-गोल्फ प्रश्न है, जिसके लिए आपको अपने कोड की लंबाई कम करने का प्रयास करना होगा। आपको 1 वर्ण लंबा होने के लिए अनावश्यक व्हाट्सएप और नाम बदलने के चर को हटा देना चाहिए।

— गेहूं जादूगर

आप पूरे वाक्यांश को एक पंक्ति में रख सकते हैं, एक जगह के लिए संकेत को कम कर सकते हैं, प्रिंट को एक पंक्ति में एक साथ रख सकते हैं यदि और, और प्रिंट में व्हाट्सएप आवश्यक नहीं है। वैसे भी, मुझे नहीं पता कि आपको सभी आउटपुट प्रिंट करने की अनुमति है या नहीं;)

— मेगा मैन

1

हैलो! ऐसा लगता है कि यह आपका पहला कोड गोल्फ उत्तर है। दुर्भाग्य से, आपको यह प्रश्न गलत लगा, विशेषकर नीचे "उदाहरण" तालिका, जिसमें दिखाया गया है कि प्रत्येक इनपुट को संबंधित आउटपुट में कैसे जाना चाहिए। वर्तमान में, आपका प्रोग्राम सिर्फ उस तालिका को प्रिंट करता है। इसके अलावा, बेहतर कोडेबिलिटी के लिए एक कोड ब्लॉक में अपना कोड रखने के लिए यह स्टैंडर प्रैक्टिस है (इसका चयन करें और {} पर क्लिक करें) और इस साइट के रूप में अपनी पसंद और बाइट काउंट की भाषा का उल्लेख करें। Q & A साइट की तुलना में अधिक प्रतियोगिता ।_ व्हीट विजार्ड पहले से ही ऐसा कर चुके हैं, इसलिए यह बेहतर है

— ivzem

नमस्ते और पीपीसीजी में आपका स्वागत है। आप रिक्त स्थान हटाने और एकल पत्र चर का उपयोग करके बहुत सारे बाइट्स खो सकते हैं। मुझे याद है कि जब मैंने पहली बार यहां शुरुआत की थी तो इसकी आदत पड़ने में कुछ समय लगा था। मुझे लगता है कि आप मेरी तरह हैं। आप पढ़ने योग्य कोड लिखने में बहुत समय बिताते हैं। जैसा कि मैंने कहा, PPCG और एक नई दुनिया में आपका स्वागत है;)

— ElPedro

6

रोड़ा , 299 292 288 259 बाइट्स

4 बाइट का उपयोग कर के लिए @fergusq करने के लिए धन्यवाद बचाया ,बजाय ..में pushबयान

बाइट्स ने मुझे @ राह दिखाने के लिए @fergusq को धन्यवाद दिया indexOf

h a{r=indexOf(a[7:8],"noarspekc")A="pain>pods>coats>strife>Player>bugs>weed>hawks>solids>sham >pseudo->petty >loose >lady >single >Tumblr >faux >platonic >!>!>.>!>!>.>!>!>!"/">";["and "];["Real"]if[r=4]else["real "];[A[r]," for my ",A[r+9],"friends",A[r+18]]}

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

इतना अजगर के करीब ... इतना करीब .... ~~आपका कदम, पायथन।~~

व्याख्या

h a{
  r=indexOf(a[7:8],"noarspekc")  /*Gets the index of the character in this string*/
  /*Variable A contains all the unique words for each test case*/
  A="pain>pods>coats>strife>Player>bugs>weed>hawks>solids>sham >pseudo->petty >loose >lady >single >Tumblr >faux >platonic >!>!>.>!>!>.>!>!>!"/">"
  ["and "]
  ["Real"]if[r=4]else["real "]   /*RealPlayer*/
  [A[r]," for my ",A[r+9],"friends",A[r+18]]   /*Print everything using var A*/
}

— क्रिकटी लिथोस
स्रोत

क्या आप अंतिम विवरण में स्ट्रिंग प्रक्षेप का उपयोग करके एक बाइट बचा सकते हैं? संपादित करें: वास्तव में सबसे छोटा रास्ता शायद कई तारों को एक के बजाय धारा की ओर धकेलना है। के ..साथ बदलें ,।

— फर्ग्यूसक

@fergusq टिप के लिए धन्यवाद!

— कृतिका लिथोस

इसके अलावा, आप बस का उपयोग कर सकते हैं r=indexOf(a[7:8],"noarspekc")।

— फर्ग्यूसक

@fergusq आह, मुझे नहीं पता था कि इस तरह के एक निर्मित अस्तित्व में था। धन्यवाद!

— क्रिति लिथोस

5

जावास्क्रिप्ट (ईएस 6), 230 228 221 216 बाइट्स

s=>'and '+((n='paonrsekc'.search(s[7]))?'real ':'')+'RealPl740s5 /450p3y /540p5-/pain0s3 /460l4 /340l3 /540T4r /350f3 /860p7 '.split`/`[n].replace(/\d\d?/g,n=>s.substr(n/10+1,n%10)||' for my ')+'friends'+'.!'[+(n>1)]

परीक्षा

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

let f =

s=>'and '+((n='paonrsekc'.search(s[7]))?'real ':'')+'RealPl740s5 /450p3y /540p5-/pain0s3 /460l4 /340l3 /540T4r /350f3 /860p7 '.split`/`[n].replace(/\d\d?/g,n=>s.substr(n/10+1,n%10)||' for my ')+'friends'+'.!'[+(n>1)]

console.log(f("Champagne for my real friends"));
console.log(f("Pseudopods for my real friends"));
console.log(f("Petticoats for my real friends"));
console.log(f("Loosestrife for my real friends"));
console.log(f("Ladybugs for my real friends"));
console.log(f("Single-payer for my real friends"));
console.log(f("Tumbleweeds for my real friends"));
console.log(f("Fauxhawks for my real friends"));
console.log(f("Platonic solids for my real friends"));

स्निपेट का विस्तार करें

— Arnauld
स्रोत

3

PHP, 202 220 204 203 बाइट्स

and real <?=[pods,solids,hawks,strife,RealPlayer,pain,bugs,weed,coats][$q=md5($argv[1].LnI)%9].' for my '.[pseudo,platonic,faux,loose,single,sham,lady,Tumblr,petty][$q].' -'[!$q].friends.'.!'[!$q||$q&3];

— user63956
स्रोत

3

पर्ल, 173 168 बाइट्स

नई सूचियों और इंडेंटेशन को हटाते हुए, यह पर्ल 5 कोड की 173 बाइट्स बन जाती है। बेशर्मी से लियो के रेटिना जवाब से पहला रेगेक्सप चुरा लिया। (मेरा कुछ समय लंबा था)

sub f{
  my($_)=@_;
  s,(\S+[oieyxm ])(\S{4}.+)real,and real $2\l$1,;
  s,gne,in,;
  s,ch,sh,;
  s,ti,ty,;
  s,eds,ed,;
  s,tumble,Tumblr,;
  s,real -p,RealPl,;
  s,o ,o-,;
  s,c ,c,;
  /ng|tt/?"$_.":"$_!"
}

Perl5 संस्करण के लिए> = 5.14 अन्य 5 बाइट्स को eval और नए / r regexp प्रतिस्थापन मॉडिफायर के साथ बंद किया जा सकता है। 168 बाइट्स के साथ समाप्त:

sub f{my($_)=@_;eval's,(\S+[oieyxm ])(\S{4}.+)real,and real $2\l$1Xgne,inXch,shXti,tyXeds,edXtumble,TumblrXreal -p,RealPlXo ,o-Xc ,c,;/ng|tt/?"$_.":"$_!"'=~s/X/,;s,/gr}

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

— केजेटिल एस।
स्रोत

2

सी, 367 बाइट्स

के रूप में कम के रूप में यह लग रहा था कि यह समाप्त नहीं होगा।

i,j,c;f(char*s){c=s[7]-97;char t[9],u[200];char*r=s;s+=j=c&&c-17?c-10&&c-18?c-2?5:8:3:4;for(i=0;*++s-32;t[i++]=*s);t[c-4?i:i-1]=0;for(i=0;*r++-t[0];)u[i++]=*(r-1);u[i]=32;u[i+1]=0;u[0]+=32;u[c?i:i-1]=c?c-2?c-14?32:45:0:121;printf("and %s%s for my %sfriends%c",c-15?"real ":"RealPlayer",c-15?c-13?t:"pain":"",c-13?c-4?c-17?u:"loose ":"Tumblr ":"sham ",c&&c-15?33:46);}

— Steadybox
स्रोत

2

जावा 7, 585 553 बाइट्स

import java.util.*;String c(String s){Map m=new HashMap(){{put("Ch","pain");put("Ps","pods");put("Pe","coats");put("Lo","strife");put("La","bugs");put("Si","Player");put("Tu","weed");put("Fa","hawks");put("Pl","solids");put("Ch1","sham ");put("Ps1","pseudo-");put("Pe1","petty ");put("Lo1","loose ");put("La1","lady ");put("Si1","single ");put("Tu1","Tumblr ");put("Fa1","faux ");put("Pl1","platonic ");}};String r=s.substring(0,2);int c=r.charAt(1);return"and "+(c=='i'?"Real":"real ")+m.get(r)+" for my "+m.get(r+1)+"friends"+(c=='i'|c=='e'?'.':'!');}

-32 बाइट्स @Zircon के लिए धन्यवाद ।

निश्चित रूप से एक मानचित्र से अलग कुछ का उपयोग करके गोल्फ हो सकता है ..

स्पष्टीकरण:

import java.util.*;            // Import required for the Map & HashMap
String c(String s){            // Method with String parameter and String return-type
  Map m=new HashMap(){{        //  The Map
    put("Ch","pain");put("Ps","pods");put("Pe","coats");put("Lo","strife");put("La","bugs");put("Si","Player");put("Tu","weed");put("Fa","hawks");
                               //  Add mapping from first two characters with first word
    put("Ch1","sham ");put("Ps1","pseudo-");put("Pe1","petty ");put("Lo1","loose ");put("La1","lady ");put("Si1","single ");put("Tu1","Tumblr ");put("Fa1","faux ");put("Pl1","platonic ");
                               //  Add mapping from first two characters + "1" with second word (+ space or '-' for edge-case `pseudo-friends`)
  }};                          // End of Map initialization
  String r=s.substring(0,2);   //  Get the first two characters of the input String
  int c=r.charAt(1);           //  Get the second character
  return "and "                //  return "and "
    + (c=='i'?"Real":"real ")  //   + "Real" or "real " for edge-case `RealPlayers`
    + m.get(r)                 //   + first word from Map
    + " for my "               //   + " for my "
    + m.get(r+1)               //   + second word from Map
    + "friends"                //   + "friends"
    + (c=='i'|c=='e' ? '.'     //   + '.' for edge-cases 'Petticoats' and 'Single-player
      : '!');                  //     or '!' for all other cases
}                              // End of method

टेस्ट कोड:

इसे यहाँ आज़माएँ। (ideone.com को हाल ही में खराब किया गया है, इसलिए मैं अब TIO का उपयोग कर रहा हूं ..)

import java.util.*;
class M{
  static String c(String s){Map m=new HashMap();m.put("Ch","pain");m.put("Ps","pods");m.put("Pe","coats");m.put("Lo","strife");m.put("La","bugs");m.put("Si","Player");m.put("Tu","weed");m.put("Fa","hawks");m.put("Pl","solids");m.put("Ch1","sham ");m.put("Ps1","pseudo-");m.put("Pe1","petty ");m.put("Lo1","loose ");m.put("La1","lady ");m.put("Si1","single ");m.put("Tu1","Tumblr ");m.put("Fa1","faux ");m.put("Pl1","platonic ");String r=s.substring(0,2);int c=r.charAt(1);return"and "+(c=='i'?"Real":"real ")+m.get(r)+" for my "+m.get(r+1)+"friends"+(c=='i'|c=='e'?'.':'!');}

  public static void main(String[] a){
    System.out.println(c("Champagne for my real friends"));
    System.out.println(c("Pseudopods for my real friends"));
    System.out.println(c("Petticoats for my real friends"));
    System.out.println(c("Loosestrife for my real friends"));
    System.out.println(c("Ladybugs for my real friends"));
    System.out.println(c("Single-player for my real friends"));
    System.out.println(c("Tumbleweeds for my real friends"));
    System.out.println(c("Fauxhawks for my real friends"));
    System.out.println(c("Platonic solids for my real friends"));
  }
}

— केविन क्रूज़सेन
स्रोत

1

मुझे लगता है कि आप डबल ब्रेस इनिशियलाइज़ेशन और putइसके बजाय का उपयोग करके बाइट्स बचा सकते हैं m.put।

— ज़िरकोन

2

सी (जीसीसी) , 311 बाइट्स

स्पष्ट पैटर्न, लेकिन इतने सारे अपवाद। फिर भी, इससे बेहतर तरीका और होना चाहिए!

f(char*s){char*t="\"5$#(=931",*r[]={"pain", "sham","pods","pseudo","coats","petty","strife","loose","bugs","lady","Player","single","weed","Tumblr","hawks","faux","solids","platonic"};int i=strchr(t,*s^s[2])-t;printf("and %s%s for my %s%cfriends%c",i^5?"real ":"Real",r[i*2],r[i*2+1],i^1?32:45,i^5&&i^2?33:46);}

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

— gastropner
स्रोत

मेरे असली दोस्तों के लिए कोड गोल्फ

उदाहरण

रेटिना , 119 बाइट्स

पायथन 2, 291 269 293 255 247 बाइट्स

एसओजीएल , 143 बाइट्स

पायथन 3 , 788 , 403 , 359 396 बाइट्स

रोड़ा , 299 292 288 259 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 230 228 221 216 बाइट्स

परीक्षा

PHP, 202 220 204 203 बाइट्स

पर्ल, 173 168 बाइट्स

सी, 367 बाइट्स

जावा 7, 585 553 बाइट्स

सी (जीसीसी) , 311 बाइट्स