“ගූගල්” ගූගල් නොකරන්න


158

ඔබ "ගූගල්" යන වචනය ගූගල් කළහොත් එය අන්තර්ජාලය බිඳ දමනු ඇති බව අපි කවුරුත් දනිමු.

ඔබේ කර්තව්යය වන්නේ එක් නූලක් පිළිගෙන එහි දිග ආපසු ලබා දෙන ශ්‍රිතයක් නිර්මාණය කිරීමයි.

කෙසේ වෙතත්, දී ඇති නූල google(කුඩා අකුරු) නම්, එය දෝෂයක් ඇති කරයි.

උදාහරණයක් ලෙස, g('bing')නැවත පැමිණෙන 4නමුත් g('google')දෝෂයක් ඇති කරයි.

කරුණාකර භාවිතය පිළිබඳ උදාහරණයක් සපයන්න, සහ හැකි නම් දෝෂය.

නාමාවලිය

මෙම ලිපියේ පතුලේ ඇති ස්ටැක් ස්නිපටය පිළිතුරු වලින් නාමාවලිය උත්පාදනය කරයි. අ) එක් භාෂාවකට කෙටිම විසඳුම් ලැයිස්තුවක් ලෙස සහ ආ) සමස්ත ප්‍රමුඛ පුවරුවක් ලෙස.

ඔබගේ පිළිතුර පෙන්වන බව සහතික කර ගැනීමට, කරුණාකර පහත දැක්වෙන මාර්ක්ඩවුන් අච්චුව භාවිතා කරමින් ඔබේ පිළිතුර සිරස්තලයකින් ආරම්භ කරන්න:

## Language Name, N bytes

Nඔබගේ ඉදිරිපත් කිරීමේ ප්‍රමාණය කොහිද ? ඔබ ඔබේ ලකුණු වැඩි දියුණු කරන්නේ නම්, ඔබට පැරණි ලකුණු සිරස්තලයට තබා ගත හැකිය . උදාහරණයක් වශයෙන්:

## Ruby, <s>104</s> <s>101</s> 96 bytes

ඔබේ ශීර්ෂයට බහු සංඛ්‍යා ඇතුළත් කිරීමට ඔබට අවශ්‍ය නම් (උදා: ඔබේ ලකුණු ලිපිගොනු දෙකක එකතුව හෝ ඔබට පරිවර්තක ධජ ද ties ුවම් වෙන වෙනම ලැයිස්තු ගත කිරීමට අවශ්‍ය නිසා), සත්‍ය ලකුණු ශීර්ෂයේ අවසාන අංකය බවට වග බලා ගන්න :

## Perl, 43 + 2 (-p flag) = 45 bytes

ඔබට භාෂාවේ නම සබැඳියක් බවට පත් කළ හැකි අතර එය ස්නිපටයේ පෙන්වනු ඇත:

## [><>](https://esolangs.org/wiki/Fish), 121 bytes


127
මම ගූගල් ගූගල් කළ අතර ගූගල් ගූගල් ගූගල් සොයා ගත්තේය. මිථ්‍යාව අවුල් විය.
Geobits

88
EGeobits එය මම ගූගල් ගූගල් කරන්නේ දැයි බැලීමට කරන පරීක්ෂණයකි. : D
rybo111

7
ශ්‍රිතය සිද්ධි සංවේදී විය යුතුද? එය 'gOOgle' ලබා දිය යුතුද?
AXMIM

2
මම ගූගල් වෙත ගූගල් ටයිප් කරන විට (ක්‍රෝම් හි සෙවුම් තීරුව), මට ගූගල් වෙත යාමට අවශ්‍ය දැයි විමසමින් පණිවිඩයක් පැමිණියේය . (දැන් එය tld එකක් බැවින් මෙය අර්ථවත් කරයි. Com.google වැඩ). මම එය ක්ලික් කර dns බැලීමේ දෝෂයක් ඇතිවිය. අන්තර්ජාලය: කැඩී ඇත!
ක්‍රේග්

4
මෙය නැවත විවෘත කිරීමට මම ඡන්දය දෙමි. මෙම අභියෝගය සඳහා දෝෂයක් වන්නේ කුමක් ද යන්න පිළිබඳව මා කිසිදු ප්‍රශ්නයක් දැක නැති අතර එයට දැනටමත් පිළිතුරු 154 ක් ඇත, එබැවින් පිරිවිතර වෙනස් කිරීම සාධාරණ යැයි මම නොසිතමි. මෙය හොඳ ප්‍රශ්නයකට උදාහරණයක් නොවිය හැකි නමුත් එය ප්‍රමාණවත් තරම් පැහැදිලි ය. කිසියම් නිමැවුමක් දෝෂයක් ද නැද්ද යන්නට පිළිතුරක් සැබවින්ම පහළ වන්නේ නම්, කෙසේ වෙතත්, එය බොහෝ ඉහළ නැංවීම් ලබා නොගනී.
සිදුරු

Answers:


230

පයිතන් 2, 29

lambda x:len(x)/(x!='google')

දෙන්නේ ZeroDivisionErrorමත "google"එසේ දිග, සහ. මෙම සමාන Python හි booleans ප්රයෝජන ලබා ගත 0හා 1.


2
+1. ඔබට එය සැකසිය gයුතුය lambda, නැතහොත් ආදානය සමඟ එය නිර්නාමිකව අමතන්න.
සාක් ගේට්ස්

4
විනෝදය සඳහා, මම ජාවාස්ක්‍රිප්ට් ඊඑස් 6 සමඟ මෙම තාක්ෂණය අත්හදා බැලුවෙමි. එය 25 ට අවසන් වූ නමුත් Infinityදෝෂයක් විසි කරනවා වෙනුවට "ගූගල්" සඳහා නැවත පැමිණේ ...
ETHproductions

18
Ach සාක් ගේට්ස් මෙටා පිළිබඳ සම්මුතිය නම්, විශේෂයෙන් අවසර නොදුනහොත් නිර්නාමික කාර්යයන් සඳහා අවසර දීමයි. ප්‍රශ්නය මෙවැනි දෙයක් ඇඟවුම් කරන බවක් පෙනෙන්නට ඇති හෙයින් (නමුත් එය තවමත් පැහැදිලිවම අනුමත නොකරයි), ඔබ ඒ ගැන OP වෙතින් විමසිය යුතුය.
FryAmTheEggman

3
E කෙවින් ඔබ returnභාවිතා කළේ නම් ඔබට අවශ්‍ය වනු ඇතdef
FryAmTheEggman

3
විනෝදජනක ලෙස, මෙය පයිත් වෙත පරිවර්තනය කර ඇත්තේ මගේ පෙර හොඳම පයිත් විසඳුමට වඩා හොඳය. එය L/lbnb"google, බයිට් 13 කි.
isaacg

108

එක්සෙල්, අක්ෂර 23 යි

මෙය A1 හැර වෙනත් කොටුවකට අලවා ඔබගේ සෙවුම් විමසුම A1 ට ටයිප් කරන්න.

=LEN(A1)/(A1<>"google")

උදාහරණයක් වශයෙන්:

ගූගල් ගූගල්


9
එක්සෙල් භාවිතා කිරීම පිළිබඳ පොදු එකඟතාව කුමක්ද?
බීටා ක්ෂය වීම

52
Et බීටා ඩෙකේ. නිර්මාණශීලී, අසාමාන්‍ය, වැඩ කරන බව පෙනේ. සියලුම සීජී ප්‍රහේලිකා සඳහා අදාළ නොවේ, නමුත් එය මෙහි ඇත!
kdbanman

121
කළමනාකරුවන් එයට කැමතියි!
lkraider

18
එබැවින් කාර්යක්ෂම, සීජී පරිශීලකයින් ඒ සඳහා ඔබට වෛර කරනු ඇත. නමුත් ඉන්න. B3 ඔබේ ජීවිතය සදහටම වෙනස් කරයි!
සුමුරායි 8

8
එක්සෙල් භාවිතා කිරීම පිළිබඳ නිශ්චිත එකඟතාවය කුමක්ද?
GreenAsJade

81

සී #, බයිට් 43 යි

සලාහ් අලාමිගේ පිළිතුරට වඩා වැඩි දියුණුවක්. "ගූගල්" සැපයීම මත තොග පිටාර ගැලීමේ ව්‍යතිරේකයක් විසි කිරීමට පුනරාවර්තනය වේ

int g(string s)=>s!="google"?s.Length:g(s);

2
ඔව්, මම සිතුවේ එය ව්‍යතිරේකයක් විසි කිරීම සඳහා සමහර චරිත සුරැකීමට ඉතා දක්ෂ ක්‍රමයක් බවයි. අක්ෂර 4 කින්, එය C # හි ව්‍යතිරේකයක් විසි කිරීමේ කුඩාම ක්‍රමය විය හැකිය, විශ්වාස නැත.
DLeh

6
මෙය දක්ෂයි! කෙසේ වෙතත්, C # හි මෑත සංස්කරණ වල වලිග පුනරාවර්තනය සඳහා සහය ඇත, එබැවින් මෙම ශ්‍රිතය කිසි විටෙකත් විසි නොකරනු ඇත StackOverflowException. ඇත්ත වශයෙන්ම එය කිසි විටෙකත් ආපසු නොඑනු ඇත (හැසිරේ while(true){}).
නයිට් එල්ෆික්

2
LDLeh Tail පුනරාවර්තන ඇමතුම් ටිකක් උපක්‍රමශීලීයි. ඔබ x64 JIT මත ධාවනය කළ යුතු අතර නිදොස්කරණයකින් තොරව (නිදොස්කරණය අමුණා ඇති නිසා පැහැදිලි හේතුන් මත වලිග පුනරාවර්තනය ක්‍රියා නොකරයි). මෙන්න මගේ වැඩසටහන සාක්‍ෂියක් ලෙස: imgur.com/ErNl8LJ සහ වලිග පුනරාවර්තනය පිළිබඳ තව ටිකක් කියවීම: blogs.msdn.com/b/davbr/archive/2007/06/20/… ;)
NightElfik

13
හහා: g (නූල්) ... මම මාවම බලන්නම් ...
ග්‍රෙග්ස්ඩෙනිස්

1
@DLeh ඔහ් ඉන්න එපා මට ඔබේ බයිට් 43 ට ගැලපෙන නමුත් එය පරාජය කළ නොහැක. :) int g (string s) => s! = "google"? s.Length: s [9];
ලී

57

පයිත්, අක්ෂර 14 13

L/lbnb"google

නම් කරන ලද ශ්‍රිතයක් අර්ථ දක්වයි y.

නූල ගූගල් නොවේ නම් මෙය දිග 1 කින් ද වෙනත් ආකාරයකින් 0 කින් ද බෙදයි . අදහස නවකතාවක් නොවේ, නමුත් මම එය ස්වාධීනව ඉදිරිපත් කළෙමි.

එය මාර්ගගතව උත්සාහ කරන්න.

එය ක්‍රියාත්මක වන ආකාරය

L                 Define y(b):
  lb                Compute len(b).
    nb"google       Compute (b != "google").
 /                  Set _ = len(b) / (b != "google").
                  Return _. (implicit)

ඔව්, මට මේ ගැන ඇත්ත වශයෙන්ම විශ්වාස නැත, එය නූලකින් පෙර සිදු වූ බව මම නොසිතමි. සාමාන්‍යයෙන් ඔබට එය වසා දැමිය හැකි ;නමුත් පැහැදිලිවම ඔබට මෙහි සිටිය නොහැක ...
FryAmTheEggman

ඔබට අවසාන උපුටා ගැනීම අවශ්‍ය නොවේ.
මෝල්ටිසන්

48
" නම් කරන ලද ශ්‍රිතයක් අර්ථ දක්වයි y. " නමුත් yඔබේ කේතයේ කිසිවක් නොමැත !
AL

46
@AL ඒක හරි. සාදන Lලද ශ්‍රිතය නැවත අර්ථ yදක්වයි.
ඩෙනිස්

91
මට විශ්වාස නෑ, නමුත් මම හිතන්නේ මම පයිත්ට වෛර කරනවා.
ලිස්ටර් මහතා

40

මැට්ලබ්, 63 41 40 38 36 බයිට්

බයිට් 1 ක් කපා දැමීම ගැන ටොම් කාපෙන්ටර්ට ස්තූතියි!

බයිට් 2 ක් කපා දැමීම ගැන ස්ටීවි ග්‍රිෆින්ට ස්තූතියි!

@(x)nnz(x(+~strcmp('google',x):end))

අනෙක් වඩාත් අලංකාර විසඳුම් මෙන් නොව, MATLAB හි ශුන්‍ය ක්‍රියාකාරිත්වය මගින් බෙදීමක් සිදු කිරීමෙන් දෝෂයක් නොලැබෙනු ඇත Inf. මෙම විසඳුම මගින් නූල් වල දිග සොයා ගනී nnz. නිපදවන නූල ඔබ නූල් ආරම්භයේ සිට අවසානය දක්වා සුචිගත කරන ආකාරයට වන අතර එය අත්‍යවශ්‍යයෙන්ම නූලෙහි පිටපතකි. කෙසේ වෙතත්, වැදගත් දෙය නම්, ආදානය සමානද නැද්ද යන්න පරීක්ෂා කිරීමෙන් නූල් වෙත ප්‍රවේශ විය යුතු ස්ථානය ආරම්භ කිරීමයි 'google'. එය එසේ නොවේ නම්, මෙය ආරම්භක දර්ශකය 1 ක් නිපදවන අතර අපි සාමාන්‍යයෙන් නූලට දර්ශක කරමු ... MATLAB 1 හි සුචිගත කිරීම ආරම්භ කරන විට, එය සමාන විය යුතු නම්, නිපදවන දර්ශකය 0 වන අතර MATLAB මඟින් සුචිගත කිරීමේ දෝෂයක් ඇතිවේ දර්ශකය ධනාත්මක පූර්ණ සංඛ්‍යාවක් විය යුතුය. අමතර+සමානාත්මතා පරීක්‍ෂණයේ ප්‍රතිදානය බූලියන් / ට වඩා සංඛ්‍යාත්මක බව සහතික කිරීම ය logical. සැර බාල වූ +අනතුරු ඇඟවීමක් නිෂ්පාදනය කරනු ඇත, නමුත් මේ අභියෝගය පිරිවිතරයන්ට අනතුරු ඇඟවීම් ඉඩ නැති නිසා, මේ +අනුව කේතය සම්පූර්ණ අවශ්ය වේ ....

උදාහරණ භාවිතා කරයි

>> f=@(x)nnz(x(+~strcmp('google',x):end)) %// Declare anonymous function

f = 

    @(x)nnz(x(+~strcmp('google',x):end))

>> f('bing')

ans =

     4

>> f('google')
Subscript indices must either be real positive integers or logicals.

Error in @(x)nnz(x(+~strcmp('google',x):end))

වඩාත් විනෝදජනක අනුවාදයක්, 83 77 76 74 72 බයිට්

බයිට් 1 ක් කපා දැමීම ගැන ටොම් කාපෙන්ටර්ට ස්තූතියි!

බයිට් 2 ක් කපා දැමීම ගැන ස්ටීවි ග්‍රිෆින්ට ස්තූතියි!

@(x)eval('if strcmp(''google'',x),web([x ''.com/i'']);else nnz(x),end');

ඉහත දැක්වෙන්නේ නිල ඉදිරිපත් කිරීමක් නොවේ, නමුත් එය ක්‍රියාත්මක කිරීමට ටිකක් විනෝදජනක දෙයකි. evalනිර්නාමික කාර්යයන් තුළ අනිසි ලෙස භාවිතා කිරීම , කේතය කරන්නේ එය ආදාන නූලට සමාන 'google'දැයි පරීක්ෂා කර බැලීමයි ... එය එසේ නම්, මෙය MATLAB හි සාදන ලද වෙබ් බ්‍රව්සරය විවෘත කර ගූගල් හි 404 දෝෂ පිටුවට පිවිසීමට උත්සාහ කරන බව පෙන්වයි. උප පිටුව iඑය නොපවතින ස්ථානයක පිහිටා ඇත . එසේ නොවේ නම්, අපි සාමාන්‍යයෙන් නූල් වල දිග පෙන්වමු.

උදාහරණ භාවිතා කරයි

>> f=@(x)eval('if strcmp(''google'',x),web([x ''.com/i'']);else nnz(x),end'); %// Declare anonymous function
>> f('bing')

ans =

     4

>> f('google')
>> 

අවසන් වරට භාවිතා කළ ඇමතුම 'google'අපට මෙම තිරය ලබා දෙයි:

රූප විස්තරය මෙහි ඇතුළත් කරන්න


3
strcmpඒ වෙනුවට භාවිතා කිරීමෙන් ඔබට බයිට් එකක් ඉතිරි කළ හැකිය isequal.
ටොම් වඩු කාර්මිකයා

OmTomCarpenter - විහිලු. මම ඇත්ත වශයෙන්ම භාවිතා කිරීමට මට පැවසූ strcmpනමුත් isequalකිසියම් හේතුවක් නිසා භාවිතා කිරීම අවසන් කළෙමි .... ස්තූතියි!
rayryeng

2
nnzබයිට් දෙකක් වඩා කෙටි වේ numel. මීට වසර කිහිපයකට පෙර ඔබට මගේ ඡන්දය ලැබුණි :-)
ස්ටීවි ග්‍රිෆින්

30

JavaScript ES6, අක්ෂර 34 27 25

f=>f=='google'?Δ:f.length

Δගූගල් සඳහා යොමු දෝෂයක් විසි කරයි .


10
බයිට් දෙකක් ඉතිරි කිරීමට ඔබට ත්‍රිමාණ ක්‍රියාකරු භාවිතා කළ හැකිය.
කොන්රාඩ් බොරොව්ස්කි

2
ඔව්, ඒක තමයි මට දැන් ලැබුණේ. ඔබට මනස්කාන්ත වීමට අවශ්‍ය නම්, g වෙනුවට මිනිසුන් කිසි විටෙකත් භාවිතා නොකරන සංකේතයක් භාවිතා කරන්න, එය ගෝලීය විචල්‍යයක් ලෙස නොපවතින බවට වග බලා ගන්න. Variable හොඳ විචල්‍ය නාමයක් ඇති කරයි :)
ඩොමිනෝ

1
ඔබට භාවිතා කළ හැකිය #, එය JS afaik
clapp හි දෝෂ

7
Ill ගූගල් ඉලුමිනාටි තහවුරු

2
මම මේක මෙතනින් යන්නම් github.com/Rabrennie/anything.js
sagiksp

26

TI-BASIC, බයිට් 15 යි

හෙක්, අපි එහි සිටින විට , මෙහි TI-BASIC පිළිතුරක් ලබා ගත හැකිය.

ආදාන ආකෘතිය "string":prgmNAME. එය මුලින්ම සොයා ගැනීම සඳහා තෝමස් ක්වාට ගෞරවය !

length(Ans)+log(Ans≠"GOOGLE

(මාර්ගෝපදේශය: ඉහළ අකුරක් වෙනුවට සෑම කුඩා අකුරකටම බයිට් 1 ක් එක් කරන්න. ඉතින් s/GOOGLE/google/g => +6 bytes.)

පරීක්ෂණ අවස්ථා!

"GOGGLE":prgmG
               6
"BING":prgmG
               4
"GOOGLE":prgmG
           Error

20 බයිට්: length(Ans)/(Ans≠"google. ඔබට නඩුව ද වැරදිය. ලොකු අකුරට අවසර දුන්නොත් එය බයිට් 14 කි. මාර්ගය වන විට, Ans හරහා තර්ක ඉදිරිපත් කිරීම වලංගු වේ.
lirtosiast

AGOOGLE7 ක් දිය යුතුයි, හරිද? ඔබ ඔබේ කේත ප්‍රමාණයෙන් වැඩසටහන් ශීර්ෂය ගණන් නොගත යුතුය, එබැවින් බයිට් 10 ක් අඩු කරන්න.
lirtosiast

දෝෂය: මම සිතුවේ උපස්ථර. කරුණාකර මට සමාව දෙන්න.
කොනර් ඕ බ්‍රයන්

1
H තෝමස්ක්වා කේතය සමඟ ඔබේ අදහස මා දුටුවේ නැත. එය එසේ වන්නේ අප දෙදෙනාම එකම විසඳුමකට පැකිලීමෙනි. කෙසේ වෙතත්, ඔබ ණය ලැබිය යුතු යැයි ඔබ විශ්වාස කරන්නේ නම්, ණය ඔබට හිමි වේ. ^ _ ^ ( සංස්කරණය කරන්න ඔබ කේතය කියවන්නේ නම් එය හරියටම එකම දෙය නොවේ.)
කොනර් ඕ බ්‍රයන්

irlirtosiast length( යනු බයිට් දෙකක් වන අතර එමඟින් ඔබේ අංක 21 සහ 15 බයිට් බවට පත් වේ.
ටිම්ටෙක්

23

ඒපීඑල් (14)

(⍴÷'google'∘≢)

පැහැදිලි කිරීම:

  • : දිග
  • ÷: බෙදනු ලැබේ
  • 'google∘≢: තර්කය සමාන නොවේ 'google'.

නූලට සමාන නොවේ නම් එය 1 න් බෙදනු ලැබේ google (දිග නැවත නොවෙනස්ව ලබා දෙන), හෝ වැල නම් 0 විසින් කරන්නේ සමාන google(දෝෂයක් ලබා).


11
මම හිතන්නේ ඔබට පරෙන්ස් ගණන් කිරීමට අවශ්‍ය නැත, මන්ද එය නොමැතිව විචල්‍යයකට එය පැවරිය හැකිය.
jimmy23013

තනි වර්‍ග තර්ක මත කරුණාව අසමත් වේ. ආදේශ කිරීමෙන් සවි කරන්න . එසේම, ඔපෙරන්ඩ්ස් මාරු කිරීමෙන් ඔබට එය සිසිල් පෙනුමක් ලබා ගත හැකිය . ඔහ්, පාරෙන් ඉවත් කිරීමට අමතක නොකරන්න. සියල්ලටම:≢÷≢∘'google'
ඇඩම්

21

පයිතන් 3, බයිට් 30 යි

lambda u:[len][u=='google'](u)

1-මූලද්‍රව්‍ය ශ්‍රිත ලැයිස්තුව දර්ශක කරයි, a IndexError , u=='google'පුරෝකථනය True(= 1) නම් ඉහළ නංවයි . එවැනි ක්රියාකාරී.

බොහෝ ප්රභේද. වොව්:

lambda u:[len(u)][u=='google']
lambda u:len([u][u=='google'])

අභියෝගය පෙරළා ඇත්නම් (සෑම දෙයකම දෝෂයක් නොමැත "ගූගල්" ), වර්‍ගයක් සුරැකිය හැක:

lambda u:{'google':len}[u](u)

නමුත් ඔබ දැනටමත් දිග දන්නවා, ඒ නිසා එය තද කරන්න.


පයිතන් 2.7 සඳහාද ක්‍රියා කරයි
නූඩ්ල් 9

කිසියම් හේතුවක් නිසා, මම මෙම විසඳුමට කැමතියි.
ෆොස්ලොක්

19

හැස්කෙල්, බයිට් 24 යි

g s|s/="google"=length s

ප්‍රතිදානය:

Main> g "google"

Program error: pattern match failure: g "google"

Main> g "bing"
4

16

ඔක්ටේව්, බයිට් 63 යි

එය මැට්ලැබ් විසඳුමට වඩා දිගු බව මම දනිමි (එය ඔක්ටේව්හි ද ක්‍රියා කරයි), නමුත් එය විශේෂයෙන් නපුරු ය. මම නිර්නාමික ශ්‍රිතයක් (නපුරක්) කරන්නේ සෛල අරාව (නපුරු) වචනානුසාරයෙන් (නපුර) ශ්‍රිත හැසිරවීම් අඩංගු වන අතර එය ඇමතුම් ආපසු ගැනීමේ ශ්‍රිතයක් මත රඳා පවතී (එයම, මේ අනුව පුනරාවර්තන, නපුර) එය තර්කය හරහා සම්මත කළ යුතුය. ඉන්පසුව මම තවත් නිර්නාමිකයක් නිර්මාණය කරමි, එය මූලික වශයෙන් ශ්‍රිතය තර්කයට අඩු කරන අතර දෙවන තර්කය නිවැරදි fකරයිf (ඉතා නපුරු) . ඕනෑම බුද්ධිමත් මිනිසෙකු මෙය කිසි විටෙකත් නොකරනු ඇත, මන්ද එය පර්ල් හෝ රීජෙක්ස් (හෝ cjam / pyth / වෙනත් ඕනෑම esolang) තරම් කියවිය නොහැකි බැවිනි.

එබැවින් නූල 'ගූගල්' නොවේ නම්, සෛල අරාවේ දෙවන තර්කය හැඳින්වෙන්නේ එය නූල් වල දිග ප්‍රතිදානය කරයි. එසේ නොමැතිනම් පළමු ශ්‍රිතය කැඳවනු ලැබේ, එය ඇමතුමක් ලෙස සම්මත වන අතර (එය තමාටම ඇමතුමක් ලෙසද ලබා දෙයි) එය පසුව ශ්‍රිතය වේ. දෝෂය මූලික වශයෙන් පුනරාවර්තන ගැඹුරේ දෝෂයකි.

f=@(s,f){@()f(s,f),numel(s)}{2-strcmp(s,'google')}();@(s)f(s,f)

2
බොහෝ භාෂාවල එම දේවල් නපුරු නොවේ. මෙම වන කේතය ගොල්ෆ්, මෙම ග්රහ ලෝකයේ ඇති බොහෝ කියවිය කේතය සමහර මෙතන පවතී :). සිසිල් හසුරුව btw.
බාර්

9
මට evalමෙහි සමහරක් අතුරුදහන් වී ඇත්තේ එය ඇත්ත වශයෙන්ම EVIL :-)
ලුයිස් මෙන්ඩෝ

15

සී ජෑම්, අක්ෂර 16 යි

{_,\"google"=!/}

නූල ගූගල් නොවේ නම් මෙය දිග 1 කින් ද වෙනත් ආකාරයකින් 0 කින් ද බෙදයි . අදහස නවකතාවක් නොවේ, නමුත් මම එය ස්වාධීනව ඉදිරිපත් කළෙමි.

එය මාර්ගගතව උත්සාහ කරන්න.

එය ක්‍රියාත්මක වන ආකාරය

_                 Push a copy of the string on the stack.
 ,                Compute the length of the copy.
  \               Swap the length and the original string.
   "google"=      Push 1 if the string is "google", 0 otherwise.
            !     Apply logical NOT. Maps 1 to 0 and 0 to 1.
             /    Divide the length by the Boolean.

සිත්ගන්නා කරුණ නම්, සම්පූර්ණ වැඩසටහනක් කෙටි වේ (බයිට් 15) : q_,\"google"=!/. මෙම ලිපිය බැලීමට පෙර එය සංවර්ධනය කරන ලදි. මෙය සමස්තයක් ගන්නා බව සලකන්න ආදානය ගන්නා බව සලකන්න (ඔබ කෙසේ හෝ ශ්‍රිත තර්කයක් ලෙස සලකන බව පෙනේ). අවාසනාවකට මෙන්, ඔබට එය භාවිතා කළ නොහැක, මෙය ශ්‍රිතයක් ඉල්ලා සිටින බැවින් :(
එරික් ද Outgolfer

12

ජාවාස්ක්‍රිප්ට්, බයිට් 25 යි

ලස්සන හා සරල ජාවාස්ක්‍රිප්ට් උදාහරණය:

e=>e!='google'?e.length:g

"ගූගල්" ඇතුලත් කර ඇත්නම් එය සමත් වේ ReferenceError

උදාහරණයක්

alert((e=>e!='google'?e.length:g)('test'))


2
වාව්, ජාවාස්ක්‍රිප්ට් හි ලැම්ඩා කාර්යයන් සඳහා කෙටි යෙදුමක් ඇති බව මට පැවසීම ගැන ස්තූතියි!
ටොමේ සැටෝ - මොනිකා නැවත

3
@ ටොම්සැටෝ කේවියට්: ඒවා ES2015 හි අළුත් ඒවා බැවින් සහාය තවමත් වෙනස් වේ.
ඇන්කෝ

11

ඒපීඑල්, බයිට් 19 17

{⍵≡'google':⍟⋄≢⍵}

මෙය නම් නොකළ මොනාඩික් ශ්‍රිතයක් වන අතර එය ආදානය නම් සින්ටැක්ස් දෝෂයක් ඇති කරයි google. කිසිවක් සිදු නොවන ස්වාභාවික ල ar ු ගණකය ගැනීමට උත්සාහ කිරීමෙන් මෙය සිදු වේ.

{
 ⍵≡'google':          ⍝ If the right argument is "google"...
            ⍟⋄        ⍝ Compute log(<nothing>), which brings only sadness
              ≢⍵      ⍝ Otherwise compute the length
}

එය මාර්ගගතව උත්සාහ කරන්න

ඩෙනිස්ට ස්තූතියි බයිට් දෙකක් ඉතිරි කළා!


අවිධිමත් ලෙස "ස්ප්ලැට්" ලෙස හැඳින්වේ. මෙම භාවිතය සඳහා ඉතා සුදුසු නමකි.
ඇඩම්

9

ආර්, බයිට් 46 යි

g=function(x)ifelse(x!="google",nchar(x),)

මම වැරදියට කියවන්නේ නැත්නම්, මුල් පෝස්ට් එකෙහි කේතය නිවැරදි වාක්‍ය ඛණ්ඩයක් විය යුතු යැයි සඳහන් කර නැත.

උදාහරණයක්:

> g("bing")
[1] 4
> g("google")
Error in ifelse(x != "google", nchar(x), ) : 
  argument "no" is missing, with no default

අයිෆෙල්ස් ප්‍රකාශයේ "නැත" පරාමිතිය සඳහා මම කිසි විටෙකත් කිසිවක් එකතු නොකළෙමි, එබැවින් මෙම පරාමිතිය ඉවත් කළ හොත් එය දෝෂයක් නැවත ලබා දෙනු ඇත.


10
මෙන්න තරමක් කෙටි එකක්:g=function(x)nchar(x)[[x!="google"]]
flodel

9

පර්ල්, බයිට් 31 29

sub{$_=pop;y///c/!/^google$/}

-2b manatwork වලට ස්තූතියි

භාවිතය:

sub{$_=pop;y///c/!/^google$/}->("google")

මට ශ්‍රිතයකට වඩා වැඩසටහනකින් ගැලවිය හැකි නම්, පහත දැක්වෙන්නේ වලංගු වන්නේ බයිට් 20 ක් පමණි (+1 බයිට් විධාන රේඛාව)

$_=y///c/!/^google$/

දෝෂය යනු ශුන්‍යයෙන් බෙදීමයි.

පැහැදිලි කිරීම:

y///c!/^google$/ආදාන 'google' සමඟ ගැලපෙන්නේ නම් දිග නැවත ලබා දෙයි .

භාවිතය:

perl -p entry.pl input.txt

2
ඔබට එය නිර්නාමික ශ්‍රිතයක් බවට පත් කළ හැකිය : sub{…}. (එවිට ඔබ එය අමතන්න sub{…}->("google").)
manatwork

$_!=googleඒ වෙනුවට භාවිතා කරමින් බයිට් 1 ක් ඉතිරි කරන්න!/^google$/
ගේබ්‍රියෙල් බෙනමි

Ab ගේබ්‍රියෙල් බෙනමි !=නූල් සංසන්දනය කිරීමට ක්‍රියා නොකරනු ඇතැයි මම බිය වෙමි ...
ඩඩා

7

හැස්කෙල් - අක්ෂර 30 යි

g"google"=error"!";g s=length s

>g "google"
 *Exception: !
>g "str"
 3

6
දෝෂ සඳහා විශ්මය දනවන ලකුණ ඇයි? හිස් නූලක් ද එසේ නොවේ ද?
ක්‍රිට්සෙෆිට්ස්

1
මට එය වෙනස් කිරීමට යෝජනා කිරීමට අවශ්‍ය විය x=x;g"google"=x;g s=length s, නමුත් කිසියම් හේතුවක් නිසා <<loop>> ව්‍යතිරේකයන් ghci තුළට විසි නොකෙරේ.
ක්‍රිට්සෙෆිට්ස්

17
g s|s/="google"=length sඅවශ්‍යතාවය මග හැරේerror
chs

7

පයිතන් 3, බයිට් 35 යි

lambda n:len(n)if n!='google'else d

1
RyFryAmTheEggman ඇත්ත වශයෙන්ම බිටු 16 කින් අඩුය. XD
DiegoDD

1
RyFryAmTheEggman: හොඳ උපක්‍රමයක් නමුත් හැඳුනුම්පත හිස් නූල් සමඟ ක්‍රියා නොකරයි:(lambda n:len(n)*(n!='google')or d)('')
pabouk

abpabouk හරි, එය පෙන්වා දීමට ස්තූතියි.
FryAmTheEggman

7

ජාවා 7: 53 52 බයිට්

int g(String _){return"google"==_?0/0:_.length();} 

ඉහත කේතය ArithmeticExceptionශුන්‍යයෙන් බෙදීම සඳහා සහ Stringවෙනත් ඕනෑම දෙයකට විසි කරයි google. ==යොමු කිරීම සංසන්දනය කරන අතර වැඩ නොකරන බව සටහන් කිරීම වටීString වස්තූන්.

ජාවා 8: 29 බයිට්

(පහත දැක්වෙන අදහස් දැක්වීමේදී)

s->s=="google"?0/0:s.length()

1
ඔබට ජාවා 8 හි ලැම්බඩා ප්‍රකාශය ද භාවිතා කළ හැකිය: s->(s.equals("google")?null:s).length();
hjk

3
"== යොමු කිරීම සංසන්දනය කරන අතර සංගීත වස්තු සඳහා ක්‍රියා නොකරනු ඇති බව සටහන් කර ගැනීම වටී." ඇත්ත වශයෙන්ම, සියලු නූල් වස්තු වේ, එබැවින් ==ජාවා සමඟ නූල් සංසන්දනය කිරීම සාමාන්‍යයෙන් ක්‍රියා නොකරනු ඇත (ඔබ නූල් පුහුණුව මත විශ්වාසය තබන්නේ නැත්නම්, එය නරකයි). සමහර විට ඔබ ජාවාස්ක්‍රිප්ට් සමඟ ව්‍යාකූල වී තිබේද?
gengkev

1
@gengkev ඔවුන් දෙදෙනාම ලිටරල් නම්, එය ක්‍රියා කරනු ඇත්තේ එය සංගීත තටාකයේ සඳහන් එකම වස්තුව වන බැවිනි. පිරිවිතරය ලිටරල් එකක් ලබා දෙන අතර මෙහි එය ලිටරල් වේ, එබැවින් එය ක්‍රියාත්මක වනු ඇත.
යසින් හජාජ්

2
Ass යසින්හජාජ් පිරිවිතරය එය වචනානුසාරයෙන් ලබා දෙන බව මම එකඟ වෙමි, නමුත් එය උදාහරණයක් පමණි. Stdin වෙතින් ආදානය ලබා දෙන්නේ නම් හෝ වෙනමම සම්පාදනය කරන ලද වෙනත් පන්තියකින් ශ්‍රිතය කැඳවනු ලැබුවහොත් එම ශ්‍රිතය බොහෝ විට සමාන වේ. කෙසේ වෙතත්, සම්පාදක ප්‍රශස්තිකරණය (ස්ට්‍රිං ඉන්ටර්නින්) මත යැපීම දුර්වල අදහසකි, එය මා මුලින් කී දෙයයි.
gengkev

7

සී ++ 11, 54 (කේතය) + 14 (# ඇතුළත් කරන්න) = 68

හොඳයි, ශුන්‍යයෙන් බෙදීම යනු නිර්වචනය නොකළ හැසිරීමකි, එය මම දෝෂයක් ලෙස නොකියමි. ඉතින් මගේ ප්‍රවේශය.

#include<ios>
[](std::string s){return s!="google"?s.size():throw;};

භාවිතය

[](std::string s){return s!="google"?s.size():throw;}("google");

1
size()බයිට් 2 ක් ඉතිරි කිරීමට ඔබට ඇමතිය හැකිය . C ++ 14 හි, ඔබට සාමාන්‍ය ලැම්බඩාස් භාවිතා කර ප්‍රතිස්ථාපනය std::stringකළ autoහැකිය. ඔබට std::stringඒ වෙනුවට සත්‍යයක් ලබා දිය යුතුය const char*.
isanae

මම දන්නේ නැහැ @isanae std::stringඇත size()ක්රමය, ඒ සඳහා ස්තුති. මම C ++ 14 Generic බලපත්රය යටතේ අවසර ලබා ඇත lambdas දැනුවත් වෙමි, නමුත්, එතැන් සිට මම, එය මට උදව් කරන ආකාරය දන්නේ නැහැ "string"වේ const char*නොව std::string.
සෙරෙජස්

1
E සෙරෙජස් std::stringසතුව ඇති size()අතර length()එය කන්ටේනරයක් සහ නූලක් නිසා ය . නම් auto, ඔබ ඒ (std::string("google"))වෙනුවට ලැම්බඩා අමතන්න ("google"). ප්‍රශ්නය පවසන්නේ “නූල්” යනු කුමක්ද යන්න සඳහන් නොකර “1 නූල් පිළිගනී” යන්නයි.
isanae

@isanae C ++ 14 ද "google"sඉදි කළ යුතුය std::string:)
ක්වෙන්ටින්

ක්‍රියාවට නැංවීම සඳහා ඔබට කළ හැකි throw;ක්‍රියාමාර්ග std::terminate()(මෙහි වර්තමාන ව්‍යතිරේකයක් නොමැති නිසා).
ක්වෙන්ටින්

6

MUMPS, බයිට් 28 යි

g(s) q $S(s'="google":$L(s))

භාවිතය:

>w $$g^MYROUTINE("bing")                                      
4
>w $$g^MYROUTINE("google")

<SELECT>g^MYROUTINE

මන්ද? හොඳයි, $S[ELECT]මූලික වශයෙන් සංයුක්ත බහු වගන්තියක් නම්-වෙනත් ප්‍රකාශයකි - හැස්කෙල් හෝ රස්ට් වැනි භාෂාවක රටා ගැළපුමකට සමාන ය. හැර ... හැස්කල් හෝ රස්ට් මෙන් නොව, රටාවන් නිරවද්‍යතාව සඳහා පරීක්ෂා නොකෙරේ, මන්ද “සම්පාදක-කාල ආරක්ෂාව” යන සංකල්පය MUMPS වලට සම්පූර්ණයෙන්ම පිටසක්වළ ය. එබැවින් ඔබගේ ආදානය ඔබ ගණන් නොගත් රටාවක් නම්, ඔබට සුන්දර ධාවන කාල දෝෂයක් ලැබෙනු ඇත <SELECT>.


6

ජාවාස්ක්‍රිප්ට්, බයිට් 47 යි

ලස්සන හා සරලයි.

සංස්කරණය කරන්න: දැන් නීති රීති වලට අනුකූල වේ

function f(g){if(g=="google")a;return g.length}

පරීක්ෂා කිරීම

දෝෂය විසි කළා

function f(g){if(g=="google")a;return g.length}

alert(f("Hello"))
alert(f("google"))
alert(f("hi"))

කිසිදු දෝෂයක් විසි කර නැත

function f(g){if(g=="google")a;return g.length}

alert(f("Hello"))
alert(f("bing"))
alert(f("hi"))


තාක්ෂණික වශයෙන්, මෙය OP හි පිරිවිතරයන් සපුරාලන්නේ නැත. මෙම ශ්‍රිතය දිගට අනතුරු අඟවන නමුත් නැවත පැමිණේ undefined.
බංගල්

Ung බංගල් දැන් කොහොමද?
බීටා ක්ෂය වීම

1
Ing මා දකින බංගලාව. නැවත පැමිණීම අවශ්‍ය බව මට අමතක විය
බීටා ක්ෂය වීම

1
ඊඑස් 6 හි ඊතල ශ්‍රිත සහ ත්‍රික ක්‍රියාකරු භාවිතා කරමින් (එසේ නම්), ඔබට එය තව ටිකක් මිරිකා ගත හැකිය :)
Carles Alcolea

1
Et බීටා ඩෙකේ ප්‍රභවය පළමුව; මම එයට ගරු කරනවා.
කාර්ල්ස් ඇල්කොලියා

6

සී, 66 48

මුල්:

int l(long*s){return strlen(s)/((*s&~(-1L<<56))!=0x656c676f6f67);}

OSX gcc භාවිතා කිරීම,
l("duck");ප්‍රතිලාභ 4,
l("google");හේතු Floating point exception: 8.

වෙනත් වේදිකාවලදී, නියතයන් එන්ඩියනස් සඳහා සකස් කිරීමට අවශ්‍ය විය හැකිය.

කෙටි :

අඩු උපක්‍රම, එකම ප්‍රති .ල.

 l(int*s){return strlen(s)/!!strcmp(s,"Google");}

ඇවැත්නි, එය එහි සිත්ගන්නා සුළු තර්කනයකි. මම ගොල්ෆ් කොටස නිවැරදිව තේරුම් ගත්තා නම්, ඔබ කෙසේ හෝ පළමු අක්ෂර හය තනි, යෝධ අංකයකට (හැෂ් වැනි) ගැලපෙන පරිදි මාරු කරමින් සිටින අතර, එය තොගය කුඩා එන්ඩියන් නිසා "ගූගල්" ලෙස අවසන් වේ, නමුත් පසුපසට ( 0x656c676f6f67= elgoog). මේ ආකාරයේ පිස්සු පහත් මට්ටමේ දේවල් අගය කරන අපට මෙම පිළිතුරට පැහැදිලි කිරීමක් අවශ්‍ය යැයි මම සිතමි.
බ්‍රැඩන් හොඳම

ඔබට මූලික වශයෙන් එය තිබේ. එය හුදෙක් මතකය 64 බිට් අංකයකට ගබඩා කරයි. එන්ඩියනස් එය x86 ගෘහ නිර්මාණ මත 'පසුගාමී' කරයි. පෙළෙහි ඇත්තේ බයිට් 7 ක් පමණි, එබැවින් ආවරණ මතකයේ ඊළඟට ඇති ඕනෑම දෙයක් සඟවයි. එය විනෝදජනක උපක්‍රමයක්, නමුත් මම සිතන්නේ '!! strcmp (s, "google")' ඇත්ත වශයෙන්ම කෙටි ය.
අෂෙලි

1
කෙසේ වෙතත්, +1. අනිවාර්යයෙන්ම. එසේම, int අක්ෂර 4 ඉවත් කිරීමෙන් ඔබට එය කෙටි කළ හැකි යැයි මම සිතමි .
බ්‍රැඩන් හොඳම

යතුරු ලියනය කිරීමෙන් පසුව , මම එය හදුනා ගතිමි! නිසි ලෙස නැවත වෙන් කිරීමකින් තොරව, ඒකක සමඟ, වාත්තු කරනු ලැබුවහොත් char *, එම බයිට් 8 ක ගොඩවල් අවකාශයේ දත්ත දූෂිත වී තනි අංකයක් ලෙස සලකනු ලැබේ ( ). ඔබට පළමු අක්ෂර 6, + NUL + කසළ ලැබෙන්නේ එබැවිනි. එය ඉතා දක්ෂයි. භයානකයි. එය සෙග්ෆෝල්ට් නොවන්නේ මන්දැයි කල්පනා කරන්න. ඒ 8 වන කුණු බයිට් සීමාව ඉක්මවා ගොස් ඇත, නැත? 8-bitslong *64-bits8*8 = 64
බ්‍රැඩන් හොඳම

මම ඔබේ විශ්ලේෂණය දෙස බැලුවෙමි. ඔබ නිවැරදියි, මාරුව 56 විය යුතුය, 54 නොවේ. එසේම, මම දූෂිත වචනය භාවිතා නොකරමි. මතකය එක හා සමානයි, බිටු වෙනස් ලෙස අර්ථ නිරූපණය කෙරේ. තාක්ෂණික වශයෙන්, කසළ බයිට් වලට ප්‍රවේශ වීම නිර්වචනය නොකළ හැසිරීමක් වන අතර ඇත්ත වශයෙන්ම එය වැරදිය. ප්‍රායෝගිකව, එම බයිටය නිසැකවම වාගේ අනෙක් නූලට සමාන නෛතික මතක කොටසක වාසය කරන අතර සාමාන්‍යයෙන් මෙම කුට්ටි (ගොඩවල්, සිරස්, නියත) වචන ප්‍රමාණයේ ඒකක වලින් අවම වශයෙන් වෙන් කරනු ලැබේ. එබැවින් මතකය වැඩසටහනට අයත් වේ, එය නූල් හැර වෙනත් දෙයක් අඩංගු වේ.
AShelly

6

රූබි, බයිට් 29 යි

මම මුලින්ම ඉදිරිපත් කළේ ors බෝර්සුන්හෝගේ පළමු උත්සාහයට සමාන දෙයක්, නමුත් මගේ තරමක් දිගු වූ අතර ඔහු මා පළ කිරීමට පෙර එය පළ කළේය. ඔහුගේ බයිට් 30 සංස්කරණයට පෙර මෙය සමඟ පැමිණියේය :)

->s{s[/^(?!google$).*/].size}

භාවිත උදාහරණ:

$ irb
2.2.1 :001 > f = ->s{s[/^(?!google$).*/].size}
 => #<Proc:0x007fa0ea03eb60@(irb):1 (lambda)> 
2.2.1 :002 > f[""]
 => 0 
2.2.1 :003 > f["bing"]
 => 4 
2.2.1 :004 > f["google"]
NoMethodError: undefined method `size' for nil:NilClass
  from (irb):1:in `block in irb_binding'
  from (irb):4:in `[]'
  from (irb):4
  from /Users/daniel/.rvm/rubies/ruby-2.2.1/bin/irb:11:in `<main>'

සංස්කරණය කරන්න: අවුරුදු දෙකක් සහ පසුව රූබි අනුවාද කිහිපයක්

රූබි , බයිට් 25 යි

->s{+s[/^(?!google$).*/]}

ප්රතිස්ථාපනය විය String#sizeනව unary plus සමඟ කර ඇත. එය මාර්ගගතව උත්සාහ කරන්න!


පිළිවෙලට, මට මෙය වැඩ කිරීමට නොහැකි විය (මම ^තරග කණ්ඩායමෙන් පිටව යාමට පැමිණියේ නැත ).
බෝර්සුන්හෝ

Ors බෝර්සුන්හෝ මට පිළිගත යුතුව ඇත්තේ මම රිජෙක්ස් "තිරිසන් ලෙස බල කළ" බවයි. මට අවශ්‍ය ප්‍රති result ලය ලැබුණා :) මම හිතන්නේ .*අවසානයේ එය ක්‍රියාත්මක වන්නේ එයයි.
daniero

ආදාන නූලට පේළි කිහිපයක් තිබේ නම් සහ එහි රේඛාවෙහි ගූගල් අඩංගු වේ නම් කැඩී යයි. මම හිතන්නේ /\A(?!google\Z).*/mඑය නිවැරදි කරයි (බයිට් තුනක වියදමින් වුවද). ^හා $අතර, රේඛා ආරම්භයේ සහ අවසානයේ ගැලපෙන \Aහා \Zසමස්තයක් ලෙස වැල ආරම්භයේ සහ අවසානයේ නොගැලපේ.
හිස්ටොක්‍රැට්

@ හිස්ටොක්‍රැට් නමුත් ඔබට පේළි කිහිපයකින් ගූගල් කළ හැකි යැයි මම නොසිතමි;)
daniero

5

රූබි, 34 30 27 26

->x{x=='google'?t: x.size}

නොදන්නා දේ tව්‍යතිරේකය මතු කරයි.

->x{x=='google'?fail():x.size}

සංස්කරණය කරන්න: මුළුමනින්ම කියවිය හැකි සහ පැහැදිලිව පෙනෙන අනුවාදය කෙටි ...

->x{x[x=~/^(?!google$)/..-1].size}

පැරණි: පෙනෙන වෙනත් අදහස් වලට බොහෝ සෙයින් සමාන ය. ArgumentErrorX 'google' නම් ඉහළ නංවනු ඇත.


2
ඇයි ඒ වරහන්? x=='google'?t: x.size
manatwork

4

> <>, බයිට් 55 යි

i:0(?v
31&l~<v0"google"~~.?%2l
$v?(2l<S?*=2l=6:+={
&<;n

මගේ හොඳම ගොල්ෆ් ක්‍රීඩා උත්සාහය හෝ ඇල්ගොරිතම නොව, මම මෙය අත්හදා බලනු ඇතැයි සිතුවෙමි. එක් කාර්යයක් නොවේ, නමුත් මම හිතන්නේ මෙය තවමත් සුදුසුකම් ලැබිය යුතුය. මට වඩා හොඳ අනුවාදයකින් සංස්කරණය කළ හැකිදැයි මම බලමි.

දිග මුද්‍රණය කර දෝෂයක් ඇතිවීමට ඔබට අවසර තිබේ නම්, මෙන්න බයිට් 46 විසඳුමක්:

i:0(?v
2lnl~<v0"google";?%
$;?(2l<S?*=2l=6:+={

මේ ආකාරයේ බයිට් 49 පෙර විසඳුම:

i:0(?v
l0nl~<v;!?=7
:;?(2l<S?*=2l=6:+=@@g3
elgoog

කිසියම් උනන්දුවක් ඇත්නම් පැහැදිලි කිරීමක් කිරීමට ලැබීම ගැන මම සතුටු වන අතර, කරුණාකර මගේ පිළිතුරෙහි කිසියම් වැරැද්දක් තිබේ නම් හෝ ඔබට ගොල්ෆ් ක්‍රීඩා යෝජනා තිබේ නම් මට දන්වන්න.


4

Javascript ES6, 51 27 25 බයිට්

හායි, මම ගොල්ෆ් කේත කිරීමට අලුත් බැවින් මෙය තවත් බොහෝ ගොල්ෆ් කළ හැකිය, නමුත් මෙන්න එය යන්නේ:

_=>_=="google"?a:_.length

g=_=>_=="google"?a:_.length

g=_=>{if("google"==_)throw Error();return _.length}

සහ සමහර පරීක්ෂණ:

(_=>_=="google"?a:_.length)("bing")//4
(_=>_=="google"?a:_.length)("google")// Error: a is not defined

g("bing")// returns 4
g("google")// Error: a is not defined

සංස්කරණය කරන්න: එකතු කරන ලදි? if යන්න ප්‍රතිස්ථාපනය කිරීමට සහ නිර්වචනය නොකළ වස්තුවක් වෙනුවට දෝෂය ආදේශ කිරීමට.

2 වන සංස්කරණය: මගේ බයිට් ගණන වැරදියි කියා මට වැටහී g = ඉවත් කළා


4

ගොල්ෆ් ස්ක්‍රිප්ට්, 14 16 අක්ෂර

{.,\'google'=!/}

අනෙක් බොහෝ අය මෙන්, ආදානය සමඟ සසඳන්න 'google' කර ප්‍රති .ලයේ ප්‍රතිලෝමයෙන් දිග බෙදයි.

උදාහරණ වැඩසටහන්:

  • සමග'bing' (ප්රතිදාන: 4)
  • සමඟ'google' (ප්‍රතිදානය: දෝෂය: බිංදුවෙන් බෙදීමට උත්සාහ කර ඇත. )

Enn ඩෙනිස් මම ඔබේ අදහස දකිමි. එහි මුල් ස්වරූපයෙන් එය හරියටම නැවත භාවිතා කළ නොහැකි විය (ඔබට ලැයිස්තුවක් හරහා කේතය යොදන්නැයි කිව නොහැක). මා මෙය පළ කිරීමට පෙර ඔබ CJam හි මුලුමනින්ම පාහේ සමාන පිළිතුරක් ලියා ඇති බව මට වැටහුණේ නැත (ඇත්ත වශයෙන්ම මම මේ වන තෙක් CJam භාෂාවක් ලෙස නොපැහැදිලි ලෙස දැන සිටියෙමි). ඔබේ විසඳුම සඳහා +1 ද කරන්න.
pswg

4

හිරවෙලා , බයිට් 16 යි

s_l1u"google"=-/

බොහෝ දෙනෙකුට සමාන ක්‍රමයක් අනුගමනය කිරීමෙන්, "ගූගල්" ආදානය වීම 0 කින් බෙදීමක් ඇති කරයි.


4

වින්ඩෝස් කණ්ඩායම, අක්ෂර 118

IF /I "%string%"=="google" exit
echo %string%> string.txt
for %%? in (string.txt) do ( SET /A stringlength=%%~z? - 2 )

ප්‍රතිදානය% stringlength% වේ.

සම්පූර්ණ කේතය:

@echo off
del string.txt
cls
echo Type your string
echo.
set /p string=String:
IF /I "%string%"=="google" goto err
echo %string%> string.txt
for %%? in (string.txt) do ( SET /A stringlength=%%~z? - 2 )
cls
echo %stringlength%
pause
del string.txt
:err
color c
echo There seems to be an error with your input...
pause>nul

ජොෂුවා හොනිග්ගේ පිළිතුරෙන් වෙනස් කරන ලදි, මෙන්න .

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.