57

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

जैसे удали игру нуб)))

जहां )))पिछले कथन पर जोर देने के लिए जोड़ा गया है, मैं एक सिद्धांत पर काम कर रहा हूं कि )शेष स्ट्रिंग के अनुपात में निहित जोर की मात्रा के लिए सीधे आनुपातिक है, हालांकि Itentimes के अनुपात की गणना करना मुश्किल लगता है मक्खी पर, जैसा कि मैं भी गालियों का सामना करने की कोशिश कर रहा हूं, इसलिए मैं सबसे छोटा संभव कोड चाहूंगा कि मुझे गणना करने में मदद मिले कि परिणामी स्ट्रिंग क्या होनी चाहिए, 0 और 500% के बीच उत्साह के मूल्य के लिए, मूल दिया , बिना डंडा के, यह मेरे शोध में बहुत मदद करेगा क्योंकि मुझे हर बार अपनी परिकल्पना का परीक्षण करने के लिए भारी स्क्रिप्ट लिखने की जरूरत नहीं होगी।

तो, चुनौती:

एक पूर्ण कार्यक्रम या फ़ंक्शन लिखें, जो दो तर्क प्रदान करता है, अज्ञात लंबाई की एक स्ट्रिंग, और एक संख्या, पूर्णांक प्रारूप में (0 और 500 के बीच) या दशमलव प्रारूप में (0 और 5 के बीच, सटीकता के 2 बिंदुओं के साथ)।

वापसी / प्रदर्शित मूल स्ट्रिंग, की संख्या के साथ प्रत्यय )के
संख्या की गणना स्ट्रिंग संख्या तक इनपुट संख्या के अनुपात के रूप में की जाएगी।
यदि ऐसा है तो संख्या 200, या 2.00 प्रदान की गई थी, स्ट्रिंग की 200% के रूप में प्रत्यय किया जाना चाहिए )की
दशमलव स्थितियों में गोल कोष्ठकों की संख्या मायने नहीं रखती।
मुद्रण योग्य ASCII वर्णों का समर्थन करने के लिए स्क्रिप्ट की आवश्यकता होती है।
केवल अपनी पसंद के एक इनपुट नंबर प्रारूप का समर्थन करना है।

उदाहरण:

"codegolf" 125      = codegolf))))))))))
"codegolf" 75       = codegolf))))))
"noob team omg" 0.5 = noob team omg))))))
"hi!" 4.99          = hi!)))))))))))))))

उदाहरण कोड (पॉवरशेल) (दशमलव इनपुट के साथ):

Function Get-RussianString ([string]$InputStr,[decimal]$Ratio){
    $StrLen = $InputStr.Length
    $SuffixCount = $StrLen * $Ratio
    $Suffix = [string]::New(")",$SuffixCount)
    return $InputStr + $Suffix
}

Get-RussianString "codegolf" 0.5
codegolf))))

यह कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है!

code-golf string

— colsw
स्रोत

2

मैं उलझन में हूं, क्या रूसी वास्तव में )जोर देने के लिए उपयोग करते हैं !? यह कुछ एन्कोडिंग मुद्दा है?

— कप्तान मैन

2

@CaptainMan मेरा मानना है कि यह एस की तुलना में स्माइली चेहरे की तरह है !, लेकिन वे उन्हें टाइप करते हैं, यह सुपर आम नहीं है, लेकिन यह काफी प्रतिष्ठित है।

— बृहस्पतिवार

30

@CaptainMan नहीं )इमोटिकॉन कम हो गया है :)। जहाँ तक मुझे पता है, यह युवाओं के बीच बहुत आम है।

— कथा १०

4

)जोर नहीं है, यह केवल स्माइली है। जहां तक मुझे पता है, :रूसी कीबोर्ड लेआउट का उपयोग करते समय टाइप करना कठिन है , इसलिए वे बिना आंखों के मुस्कुराते हैं।

— ड्यूजिस

18

@ यह :रूसी लेआउट (ЕУК )Н) पर लिखना उतना ही कठिन है जितना कि ^QWERTY पर लिखना । लेकिन वास्तव में, )का एक कम संस्करण है :)। बार-बार वैकल्पिक कुंजियों की तुलना में Shift-0 को दबाकर रखना अधिक आसान है।

— रुस्लान

16

जेली , 7 बाइट्स

ȮL×Ċ”)x

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

दशमलव प्रारूप का उपयोग करता है।

कैसे?

ȮL×Ċ”)x - Main link: string, decimal
Ȯ       - print string
 L      - length(string)
  ×     - multiply by the decimal
   Ċ    - ceiling (since rounding method is flexible)
    ”)  - a ')' character
      x - repeated that many times
        - implicit print

— जोनाथन एलन
स्रोत

@ConnorLSW मैंने अभी देखा कि यह एक पूर्ण कार्यक्रम के रूप में आवश्यक स्ट्रिंग को प्रिंट करेगा, लेकिन यह है कि विनिर्देश "वापसी" बताता है - क्या यह ठीक है?

— जोनाथन एलन

1

कोई भी मानक स्वीकृत आउटपुट प्रारूप ठीक है

— १६:५०

कोई चिंता नहीं है - यह मेरी पहली चुनौती है इसलिए इनमें से कुछ चीजें हैं जो मुझे याद आती हैं, मैंने इसे अधिक स्पष्ट होने के लिए सवाल में अपडेट किया है - पूछने के लिए धन्यवाद।

— कोल्व्स

17

पर्ल 6, 21 बाइट्स

{$^a~")"x$^b*$a.comb}

— SMLS
स्रोत

16

आम लिस्प, 59 52 50

कोष्ठकों? मैं अंदर हूूं।

(lambda(s n)(format()"~a~v@{)~}"s(*(length s)n)0))

विवरण

(lambda(s n)               ; two arguments (string and ratio)
  (format ()               ; format as string
          "~a~v@{)~}"      ; control string (see below)
          s                ; first argument (string)
          (* (length s) n) ; second argument (number of parens)
          0))              ; one more element, the value does not matter

प्रारूप नियंत्रण स्ट्रिंग

~a : सुंदर प्रिंट तर्क (यहाँ दिए गए स्ट्रिंग)
~v@{...~}: पुनरावृति ब्लॉक, वी पुनरावृत्ति तक सीमित है, जहां वी को एक तर्क के रूप में लिया जाता है, अर्थात् (* ...)अभिव्यक्ति। किसी सूची पर पुनरावृति को माना जाता है, लेकिन जब आप @संशोधक को जोड़ते हैं , तो सूची प्रारूप फ़ंक्शन के तर्कों की शेष सूची है। पुनरावृत्त सूची में कम से कम एक तत्व होना चाहिए (अन्यथा हम बाहर निकलते हैं, वी की अवहेलना करते हैं)। यही कारण है कि प्रारूप (0) के लिए एक अतिरिक्त तर्क है।

चूंकि सूची में कोई भी तत्व प्रारूप द्वारा उपभोग नहीं किया गया है, लूप अनंत है, लेकिन सौभाग्य से, यह वी द्वारा भी बाध्य है, मुद्रित करने के लिए कोष्ठक की संख्या उर्फ।

संपादित करें: इंगित करने के लिए माइकल व्हीलर के लिए धन्यवाद कि संख्यात्मक तर्क को गोल करने की कोई आवश्यकता नहीं है (सवाल यह है कि हम चाहते हैं, लेकिन डिफ़ॉल्ट व्यवहार यहां काम करता है)

— कोर निपात
स्रोत

12

(()) / 10 पर्याप्त कोष्ठक नहीं

— BgrWorker

किसने सोचा था कि यह भाषा एक अच्छा विचार है?

— downrep_nation

योजना formatएक दशमलव तर्क को स्वीकार करती है v। शायद आम लिस्प करता है, भी?

— माइकल व्हील्स

@MichaelVehrs वास्तव में, बहुत बहुत धन्यवाद।

— coredump

1

@ कोर्डपम्प वास्तव में, मुझे "गिल की स्वीकार्यता format..." कहना चाहिए था , क्योंकि मानक योजना formatसमर्थन नहीं करती है ~r; और गुइल formatने कॉमन लिस्प के उदाहरण का अनुसरण किया।

— माइकल व्हीकल्स

9

जावास्क्रिप्ट ईएस 6, 38 31 30 बाइट्स

s=>n=>s+')'.repeat(s.length*n)

f=s=>n=>s+')'.repeat(s.length*n)

console.log(f("hi!")(4.99))

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

— टॉम
स्रोत

1

अच्छा, मुझे लगता है कि यह सबसे कम संभव है। आप एक बाइट को करीने से बचा सकते हैं: s=>n=>s+')'.repeat(s.length*n)(इसे तब कहा जाता है f("hi!")(4.99))

— ETHproductions

8

पायथन 2 , 29 बाइट्स

lambda s,p:s+len(s)*p/100*')'

स्ट्रिंग में s , p प्रतिशत (पूर्णांक) है।

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

— डेनिस
स्रोत

7

05AB1E , 9 8 बाइट्स

g*ï')×¹ì

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

g*       # Length, multiplied by emphasis.
  ï')×   # Covnerted to an integer, push that many parenthesis.
      ¹ì # Prepend original string.

पूर्णांक और दशमलव, दोनों के लिए कार्य करता है: f(String, Double)

— जादू ऑक्टोपस Urn
स्रोत

-1 के नए संस्करण में 05AB1E , जहां फ्लोट तर्क के साथ ïअंतर्निहित रूप से किया जाता है ×।

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

और यहाँ एक 7-बटर है जो विरासत और आधुनिक 05AB1E दोनों पर काम करता है: sg * F ') « ।

— ग्रैमी

7

अजगर, 30 बाइट्स

lambda s,r:s+')'*int(len(s)*r)

दशमलव इनपुट का उपयोग करता है।

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

— LevitatingLion
स्रोत

7

पायथ, 8 बाइट्स

*\)s*lpz

ऑनलाइन टेस्ट! पहले उत्साह अनुपात लेता है, फिर स्ट्रिंग के बारे में उत्साहित किया जाता है।

स्पष्टीकरण:

      pz  print out the enthused string
     l    ... and get its length
    *...Q multiply that by the ratio
   s      floor to get an integer, let's call this S
 \)       single-character string ")"
* ")" S   multiply that integer by the string, which gives a string of )s of length S.
          implicitly print that string of S )s.

— स्टीवन एच।
स्रोत

5

पॉवरशेल , 33 बाइट्स

$a,$b=$args;$a+')'*($b*$a.Length)

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

दशमलव प्रारूप का समर्थन करता है।

— briantist
स्रोत

5

आर, 62 46 42 बाइट्स

अनाम फ़ंक्शन जो स्ट्रिंग aऔर दशमलव लेता है n, आउटपुट को stdout में प्रिंट करता है।

pryr::f(cat(a,rep(")",n*nchar(a)),sep=""))

— rturnbull
स्रोत

4

अजगर, 9 बाइट्स

*s*lpzE")

इनपुट की दो लाइनें लेता है: स्ट्रिंग और अनुपात (दशमलव)।

इसे pyth.herokuapp.com पर आज़माएँ

व्याख्या

Aएक फ़ंक्शन के पहले तर्क को दर्शाता है, Bइसके दूसरे तर्क को।

*s*lpzE")
    pz     # print the input string
   lAA     # take the length of the printed string
      E    # read the next line of input (the emphasis ratio)
  *AAAB    # multiply the length by the ratio
 sAAAAA    # floor the result
*AAAAAA")  # repeat ")" n times
           # implicit print

— LevitatingLion
स्रोत

4

टीआई-बेसिक, 33 बाइट्स

दशमलव इनपुट लेता है।

Prompt Str1,A
")
For(I,0,9
Ans+Ans
End
Str1+sub(Ans,1,AI

— Timtech
स्रोत

4

पर्ल 5, 29 बाइट्स

sub{($_=pop).')'x(y///c*pop)}

(संख्या पहले arg है, स्ट्रिंग दूसरी है।)

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

— nwellnhof
स्रोत

3

CJam , 9 बाइट्स

l_,ld*')*

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

पहली पंक्ति पर इनपुट स्ट्रिंग, दूसरी में 0 से 5 की रेंज में जोर अनुपात।

व्याख्या

l    e# Read input string.
_,   e# Duplicate, get length.
ld   e# Read emphasis ratio.
*    e# Multiply by length.
')*  e# Get that many parentheses.

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

3

MATL, 11 10 8 बाइट्स

yn*:"41h

यह समाधान दूसरे इनपुट के दशमलव रूप का उपयोग करता है

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

व्याख्या

        % Implicitly grab first input as a string
        % Implicitly grab the second input as a number
y       % Make a copy of the first input
n       % Compute the length of the string
*       % Multiply the decimal by the length to determine the # of )'s (N)
:       % Create the array [1...N]
"       % For each element in this array
  41    % Push 41 to the stack (ACSII for ")")
  h     % Horizontally concatenate this with the current string
        % Implicit end of for loop and display

— Suever
स्रोत

3

sB ~, 17 बाइट्स

i\,N?\;')'*(N*l(\

व्याख्या की:

i\,N    input a string and a number
?\;     print the string
')'*    also print ) multiplied by...
(N*l(\  the number times the string length.

कोष्ठक अपने आप बंद हो जाते हैं

यहाँ संकलक का आउटपुट है, यदि आप रुचि रखते हैं:

 INPUT  S$ ,N? S$ ;")"*(N* LEN(  S$ ))

संकलक का यह संस्करण 1/27/2017 को रात 11:12 बजे लिखा गया था, जो इस प्रश्न के पोस्ट होने के कुछ मिनट बाद हो सकता है। तो यहाँ एक संस्करण है जो संकलक के सबसे पुराने संस्करण पर काम करता है, एक घंटे पहले लिखा गया है: iS$,N?S$;')'*(N*l(S$))(22 बाइट्स)

— 12Me21
स्रोत

3

PostgreSQL, 102 बाइट्स

create function q(text,int)returns text as $$select rpad($1,(100+$2)*length($1)/100,')')$$language sql

विवरण

पूर्णांक इनपुट प्रारूप का उपयोग करता है।

यह लक्ष्य स्ट्रिंग की लंबाई के साथ इनपुट स्ट्रिंग को राइट-पैड करता है।

create function q(text,int)
returns text as $$
    select rpad($1,             -- Pad the string input
        (100 + $2) *            -- to 100 + int input % ...
        length($1) / 100,       -- ...of the input string
        ')')                    -- with ) characters
$$ language sql

के साथ बुलाया गया

select q('codegolf', 125), q('codegolf', 75);
select q('noob team omg', 50), q('hi!', 499);

— हारून
स्रोत

2

बैश + कोरुटिल्स, 45 बाइट्स

echo $1`seq -s\) $[${#1}*$2/100+1]|tr -cd \)`

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

पूर्णांक इनपुट।

— मिशेल स्पेक्टर
स्रोत

echo $1`jot -b \) -s '' $[${#1}*$2/100]`40 बाइट्स :) इसे

— आजमाएं

2

ग्रूवी, 27 बाइट्स

सीधा हल

{s,r->s+')'*(s.length()*r)}

परीक्षण कार्यक्रम:

def f = {s,r->s+')'*(s.length()*r)}

println f("hi!", 4.99)
println f("noob team omg", 0.5)

— WirelessKiwi
स्रोत

2

रेबोल, 39 बाइट्स

func[a b][append/dup a")"b * length? a]

— draegtun
स्रोत

2

क्लोजर, 40 बाइट्स

काफी उबाऊ समाधान:

#(reduce str %(repeat(*(count %)%2)")"))

बस कम कर देता है strप्रारंभिक पैरामीटर के रूप में एक स्ट्रिंग के साथ कोष्ठक को बंद करने की सूची पर फ़ंक्शन को करता है।

इसे ऑनलाइन देखें: https://ideone.com/5jEgWS

नहीं-उबाऊ समाधान (64 बाइट्स):

#(.replace(str(nth(iterate list(symbol %))(*(count %)%2)))"(""")

इनपुट स्ट्रिंग को एक प्रतीक में परिवर्तित करता है (उद्धरण से छुटकारा पाने के लिए) और बार-बार इस पर फ़ंक्शन लागू करता है listजैसे कि यह अनंत अनुक्रम उत्पन्न करता है (a (a) ((a)) (((a))) ... ):। लेता हैnth तत्व स्ट्रिंग में बदल देता है और कुछ भी नहीं के साथ सभी खोलने कोष्ठकों बदल देता है।

इसे ऑनलाइन देखें: https://ideone.com/C8JmaU

— cliffroot
स्रोत

1

#(.replaceAll(str(nth(iterate list %)(*(count %)%2)))"[(\"]""")1 बाइट कम (याय)। मैं COMP करना चाहता था, लेकिन 70 बाइट्स से नीचे नहीं जा सकता।

— माइकल एम

आप एक बाइट को बचाने के ")"लिए बदल सकते हैं \)।

— 10

2

SimpleTemplate, 92 बाइट्स

पहले पैरामीटर के रूप में स्ट्रिंग और दूसरे के रूप में "अनुपात" लेता है।
2 दशमलव स्थानों के साथ अनुपात 0 और 5 के बीच है।

{@echoargv.0}{@callstrlen intoL argv.0}{@set*Y argv.1,L}{@callstr_repeat intoO")",Y}{@echoO}

जैसा कि आप देख सकते हैं, यह गैर-इष्टतम है।
2 {echo}को घटाकर 1 किया जा सकता है।
संकलक में बग के कारण, इस कोड को बहुत कम नहीं किया जा सकता है।

Ungolfed:

{@echo argv.0}
{@call strlen into length argv.0}
{@set* ratio argv.1, length}
{@call str_repeat into parenthesis ")", ratio}
{@echo parenthesis}

यदि कोई बग मौजूद नहीं है, तो कोड इस तरह दिखेगा, 86 बाइट्स:

{@callstrlen intoL argv.0}{@set*Y argv.1,L}{@callstr_repeat intoO")",Y}{@echoargv.0,O}

— इस्माइल मिगुएल
स्रोत

2

सी # इंटरएक्टिव, 77 67 बाइट्स

string r(string s,int p)=>s+new string(')',(int)(s.Length*p/100d));

C # इंटरैक्टिव मधुर है।

— पोंटस मैग्यूसन
स्रोत

1

यदि आप C # सहभागी का उपयोग कर रहे हैं जो कि शीर्ष लेख में होना चाहिए अन्यथा, C # में, आपको शामिल होना चाहिए using System;या पूरी तरह से योग्य होना चाहिए Math। इसके अलावा, निश्चित नहीं है कि आप इसे इंटरेक्टिव में कर सकते हैं, लेकिन आप Func<string, Func<int, string>>बाइट्स बचाने के लिए संकलन कर सकते हैंs=>p=>s+new...

— TheLethalCoder

1

इसके अलावा, आप शायद कॉल की जरूरत नहीं है करने के लिए Math.Roundसिर्फ एक के लिए कास्टिंग intकॉल करना चाहिए Floorऔर ओपी या तो कहा Floorया Ceilingठीक है

— TheLethalCoder

1

स्माइलबासिक, 29 बाइट्स

INPUT S$,N?S$;")"*(LEN(S$)*N)

— 12Me21
स्रोत

चूंकि 3*4.99= 14.97, केवल 14या 15उत्तर के रूप में स्वीकार्य होगा, 29 बाइट्स संस्करण को हालांकि ठीक काम करना चाहिए, क्षमा करें!

— Colsw

1

गोल> <> (गोल्फिश), 17 बाइट्स

i:a=?v
R*Il~/Hr)`

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

शीर्ष पंक्ति वर्णों को पढ़ती है ( i) जब तक कि यह एक नई रेखा (ASCII 10) को नहीं पाती है a, तब तक नीचे चली जाती है ( v)।

फिर हम एक चरित्र (न्यूलाइन) को छोड़ देते हैं ~, स्टैक की लंबाई ( l), एक फ्लोट ( I) पढ़ें , दोनों को गुणा करें, और बार-बार ( R) चरित्र को धक्का दें) "" जो कई बार। अंत में, स्टैक को उल्टा करें ( r), इसे आउटपुट करें और रोकें ( H)।

— निक मत्ते
स्रोत

1

PHP, 50 बाइट्स

<?=str_pad($s=$argv[1],strlen($s)*++$argv[2],")");

कमांड लाइन तर्क के रूप में स्ट्रिंग और दशमलव संख्या लेता है; पैडिंग में कटौती। साथ दौड़ो-r ;

टूट - फूट

<?=                     // print ...
str_pad(                    // pad
    $s=$argv[1],            // string=argument 1
    strlen($s)*++$argv[2],  // to string length*(1+argument 2) 
    ")"                     // using ")" as padding string
);

— टाइटस
स्रोत

1

रूबी, 25 बाइट्स

->(s,n){s+')'*(s.size*n)}

मैं लंबोदर का उपयोग कर रहा हूं । परीक्षा कार्यक्रम कुछ इस तरह होगा:

f=->(s,n){s+')'*(s.size*n)}
f.("codegolf", 1.5)        # => "codegolf))))))))))))"
f.("hi!", 4.99)            # => "hi!))))))))))))))"

— रॉबर्टो एस।
स्रोत

1

क्लोजर, 68 बाइट्स

एक अनाम फ़ंक्शन जो दशमलव इनपुट को स्वीकार करता है।

(fn [s n] (print (str s (reduce str (repeat (* n (count s)) ")")))))

सचमुच पहला लिस्प कार्यक्रम जो मैंने कभी लिखा है! मुझे पहले से ही मज़ा आ रहा है।

— shadowtalker
स्रोत

लिस्प की दुनिया में आपका स्वागत है! : पी क्लोजर में, आप अनाम कार्यों के संघनित रूप का उपयोग कर सकते हैं#(...) , और आप छुटकारा पा सकते हैं print(क्योंकि फ़ंक्शन रिटर्न स्वीकार्य होना चाहिए)। आप बदल सकते हैं reduceकरने के लिए applyके लिए strसमारोह, और आप बदल सकते हैं ")"करने के लिए \)जो एक ही बात करता है,। तो, अंतिम कोड होना चाहिए #(str %(apply str(repeat(*(count %)%2)\))))):।

— 10

इसके अलावा, अपने कोड की वर्तमान स्थिति के काम नहीं करता है, (#(...) "codegolf" 125)125 को जोड़ना होगा प्रतिशत "codegolf" के बजाय 125 की लंबाई के बार "codegolf" की लंबाई। तो, निर्धारित कार्यक्रम होगा: #(str %(apply str(repeat(*(count %)%2 1/100)\))))जो कि 49 बाइट्स है।

— मौसमी

1

सी ++ 14, 43 बाइट्स

अनाम लैंबडा ने अपने इनपुट को संशोधित करते हुए, मान लिया sहै कि std::string( फ्लोटिंग पॉइंट प्रकार का है .append(int,char)और माना pजाता है:

[](auto&s,auto p){s.append(s.size()*p,41);}

उपयोग:

#include<string>
#include<iostream>

auto f=
[](auto&s,auto p){s.append(s.size()*p,41);}
;


int main() {
 std::string s = "abcdefghijk";
 f(s,0.75);
 std::cout << s << std::endl;
}

— कार्ल नेफ
स्रोत

1

हास्केल , 37 बाइट्स

s!n=s++([1..div(n*length s)100]>>")")

इसे ऑनलाइन आज़माएं! उपयोग:"codegolf" ! 125

एक संस्करण जो एक दशमलव संख्या लेता है: (41 बाइट्स)

s!n=s++([1..n*toRational(length s)]>>")")

इसे ऑनलाइन आज़माएं! उपयोग:"codegolf" ! 1.25

— Laikoni
स्रोत

उत्साहपूर्वक रूसी एक स्ट्रिंग

जेली , 7 बाइट्स

कैसे?

पर्ल 6, 21 बाइट्स

आम लिस्प, 59 52 50

विवरण

प्रारूप नियंत्रण स्ट्रिंग

जावास्क्रिप्ट ईएस 6, 38 31 30 बाइट्स

पायथन 2 , 29 बाइट्स

05AB1E , 9 8 बाइट्स

अजगर, 30 बाइट्स

पायथ, 8 बाइट्स

पॉवरशेल , 33 बाइट्स

आर, 62 46 42 बाइट्स

अजगर, 9 बाइट्स

व्याख्या

टीआई-बेसिक, 33 बाइट्स

पर्ल 5, 29 बाइट्स

CJam , 9 बाइट्स

व्याख्या

MATL, 11 10 8 बाइट्स

sB ~, 17 बाइट्स

PostgreSQL, 102 बाइट्स

विवरण

बैश + कोरुटिल्स, 45 बाइट्स

ग्रूवी, 27 बाइट्स

रेबोल, 39 बाइट्स

क्लोजर, 40 बाइट्स

SimpleTemplate, 92 बाइट्स

सी # इंटरएक्टिव, 77 67 बाइट्स

स्माइलबासिक, 29 बाइट्स

गोल> <> (गोल्फिश), 17 बाइट्स

PHP, 50 बाइट्स

रूबी, 25 बाइट्स

क्लोजर, 68 बाइट्स

सी ++ 14, 43 बाइट्स

हास्केल , 37 बाइट्स