Wszyscy wiemy, że jeśli użyjesz słowa „google”, spowoduje to uszkodzenie internetu.

Twoim zadaniem jest utworzenie funkcji, która akceptuje jeden ciąg znaków i zwraca jego długość, używając jak najmniejszej liczby znaków Unicode.

Jeśli jednak podany ciąg znaków google(małe litery) spowoduje błąd.

Na przykład g('bing')wróci, 4ale g('google')spowoduje błąd.

Podaj przykład użycia i błąd, jeśli to możliwe.

Python 2, 29

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

Daje to ZeroDivisionErrorON "google", a długość inaczej. Wykorzystuje to wartość logiczną Python równą 0i 1.

Excel, 23 znaki

Wklej to do komórki innej niż A1 i wpisz wyszukiwane hasło w A1.

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

Na przykład:

C #, 43 bajty

Poprawa w stosunku do odpowiedzi Salah Alami. Powraca, aby zgłosić wyjątek przepełnienia stosu po udostępnieniu „google”

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

Pyth, 14 13 znaków

L/lbnb"google

Definiuje nazwaną funkcję y.

To dzieli długość przez 1, jeśli ciąg nie jest google, i przez 0 w przeciwnym razie. Pomysł nie jest nowy, ale wpadłem na to niezależnie.

Wypróbuj online.

Jak to działa

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

MATLAB, 63 41 40 38 36 bajtów

Dzięki Tomowi Carpenterowi za zgolenie 1 bajta!

Dzięki Stewie Griffin za zgolenie 2 bajtów!

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

W przeciwieństwie do innych bardziej eleganckich rozwiązań, wykonanie operacji dzielenia przez zero w MATLAB-ie nie spowoduje błędu, a raczej Inf. To rozwiązanie znajduje długość ciągu według nnz. Wytworzony ciąg znaków umożliwia indeksowanie od początku ciągu do końca, który jest w zasadzie kopią ciągu. Ważne jest jednak to, że początek miejsca dostępu do ciągu jest tworzony przez sprawdzenie, czy dane wejściowe są równe 'google'. Jeśli tak nie jest, daje to początkowy indeks 1, a my indeksujemy do łańcucha normalnie ... ponieważ MATLAB rozpoczyna indeksowanie od 1. Jeśli jest równy, wygenerowany indeks wynosi 0, a MATLAB zgłosi błąd indeksowania stwierdzający, że indeks musi być dodatnią liczbą całkowitą. Statysta+ma zapewnić, że wynik kontroli równości jest liczbowy, a nie logiczny / logical. Pominięcie +spowoduje wygenerowanie ostrzeżenia, ale ponieważ specyfikacja tego wyzwania nie zezwala na ostrzeżenia, +jest wymagana ... w ten sposób uzupełniając kod.

Przykładowe zastosowania

>> 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))

Bardziej zabawna wersja, 83 77 76 74 72 bajtów

Dzięki Tomowi Carpenterowi za zgolenie 1 bajta!

Dzięki Stewie Griffin za zgolenie 2 bajtów!

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

Powyższe nie jest oficjalnym oświadczeniem, ale jest czymś, co sprawia nieco więcej radości. Nadużywanie evalfunkcji anonimowych polega na tym, że sprawdza, czy ciąg wejściowy jest równy 'google'... a jeśli tak, otworzy się wbudowana przeglądarka internetowa MATLAB i wyświetli stronę błędu 404 Google próbującą uzyskać dostęp do podstrona zlokalizowana, ikiedy to nie istnieje. Jeśli nie, wyświetlamy długość łańcucha normalnie.

Przykładowe zastosowania

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

ans =

     4

>> f('google')
>> 

Ostatnie użycie połączenia 'google'daje nam ten ekran:

JavaScript ES6, 34 27 25 znaków

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

Zgłasza błąd ReferenceError Δdla google.

alert((f=>f=='google'?Δ:f.length)('test'))

TI-BASIC, 15 bajtów

Heck, gdy już nad tym jesteśmy , równie dobrze może uzyskać odpowiedź TI-BASIC tutaj.

Format wejściowy to "string":prgmNAME. Kredyt dla Thomasa Kwa na znalezienie go pierwszy!

length(Ans)+log(Ans≠"GOOGLE

(Przewodnik: dodaj 1 bajt na każdą małą literę, zastępując wielką literę. Tak s/GOOGLE/google/g => +6 bytes.)

ahhhhh przypadki testowe!

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

APL (14)

(⍴÷'google'∘≢)

Wyjaśnienie:

• ⍴: długość
• ÷: podzielony przez
• 'google∘≢: argument nie jest równy 'google”.

⍴podaje długość ciągu, która jest dzielona przez 1, jeśli ciąg nie jest równy google(co daje powrót niezmienionej), lub przez 0, jeśli ciąg jest równy google(dając błąd).

Python 3, 30 bajtów

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

Indeksuje 1-elementową listę funkcji, podnosząc wartość predykatu IndexErrorif (= 1). Taki funkcjonalny.u=='google'True

Wiele wariantów. Łał:

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

Jeśli wyzwanie zostało odwrócone (błąd we wszystkim, nie „google”), można zapisać znak:

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

Ale znasz już długość, więc po prostu ją zakoduj.

Haskell, 24 bajty

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

Wynik:

Main> g "google"

Program error: pattern match failure: g "google"

Main> g "bing"
4

CJam, 16 znaków

{_,\"google"=!/}

To dzieli długość przez 1, jeśli ciąg nie jest google, i przez 0 w przeciwnym razie. Pomysł nie jest nowy, ale wpadłem na to niezależnie.

Wypróbuj online.

Jak to działa

_                 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.

Oktawa, 63 bajty

Wiem, że jest on dłuższy niż rozwiązanie Matlab (które również działałoby w Octave), ale jest szczególnie zły. Robię anonimową funkcję (zło) za pomocą literałów macierzy komórek (zło) (zło) zawierających uchwyty funkcji zależne od funkcji wywołania zwrotnego (sama, a więc rekurencyjna, zło), którą należy przekazać argumentem. Następnie tworzę kolejny anonimowy, który zasadniczo redukuje funkcję do argumentu łańcuchowego i naprawia drugi argument fas f(bardzo zły). Każdy rozsądny człowiek nigdy by tego nie zrobił, ponieważ jest prawie tak samo nieczytelny jak Perl lub regex (lub cjam / pyth / any esolang).

Więc jeśli ciąg nie jest „google”, wywoływany jest drugi argument tablicy komórek, który wyświetla długość łańcucha. W przeciwnym razie zostanie wywołana pierwsza funkcja, która jest przekazywana jako oddzwanianie (i również sama się odsyła), która później jest samą funkcją. Błąd jest w zasadzie pewnym błędem maksymalnej głębokości rekurencji.

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

JavaScript, 25 bajtów

Ładny i prosty przykład JavaScript:

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

Jeśli wprowadzono „google”, to przechodzi ono przez ReferenceError

Przykład

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

APL, 19 17 bajtów

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

Jest to nienazwana funkcja monadyczna, która zgłosi błąd składniowy, jeśli dane wejściowe to google. Dokonuje się tego poprzez próbę zabrania naturalnego logarytmu niczego.

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

Wypróbuj online

Zaoszczędzono dwa bajty dzięki Dennisowi!

R, 46 bajtów

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

O ile się nie mylę, oryginalny post nigdy nie określał, że kod musi mieć poprawną składnię.

Przykład:

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

Nigdy nie dodałem niczego do parametru „no” instrukcji ifelse, więc zwróci błąd, jeśli ten parametr zostanie wywołany.

Perl, 31 29 bajtów

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

-2b dzięki manatwork

Stosowanie:

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

Gdybym mógł uniknąć programu, a nie funkcji, poniższe byłyby poprawne z jedynie 20 bajtami (wiersz poleceń +1 bajt)

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

Błąd to dzielenie przez zero.

Wyjaśnienie:

y///czwraca długość, a następnie !/^google$/zwraca 0 iff input pasuje do „google”.

Stosowanie:

perl -p entry.pl input.txt

Haskell - 30 znaków

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

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

Python 3, 35 bajtów

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

Java 7: 53 52 bajtów

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

Powyższy kod wyrzuci ArithmeticExceptiondo podziału przez zero i dla każdego Stringinnego niż google. Warto zauważyć, że ==porównuje odniesienia i nie będzie działać dla Stringobiektów.

Java 8: 29 bajtów

(Na podstawie sugestii podanej w komentarzu poniżej)

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

C ++ 11, 54 (kod) + 14 (#include) = 68

Cóż, dzielenie przez zero jest po prostu niezdefiniowanym zachowaniem, którego nie nazwałbym błędem. Więc moje podejście.

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

stosowanie

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

MUMPS, 28 bajtów

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

Stosowanie:

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

<SELECT>g^MYROUTINE

Dlaczego? Cóż, $S[ELECT]jest w zasadzie zwartą , złożoną z wielu klauzul instrukcją if-else - prawie jak dopasowanie wzorca w języku takim jak Haskell lub Rust. Z wyjątkiem ... inaczej niż w przypadku Haskell czy Rust wzorce nie są sprawdzane pod kątem kompletności, ponieważ pojęcie „bezpieczeństwa podczas kompilacji” jest całkowicie obce MUMPS. Jeśli więc wprowadzono wzorzec, którego nie uwzględniono, wywoływany jest piękny błąd czasu wykonywania <SELECT>.

Ruby, 34 30 27 26

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

Nieznany tpodnosi wyjątek.

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

Edycja: całkowicie czytelna i oczywista wersja, która jest krótsza ...

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

Stare: Wydaje się dość podobne do innych pomysłów. Podniesie, ArgumentErrorjeśli x to „google”.

JavaScript, 47 bajtów

Ładne i proste.

Edycja: teraz jest zgodny z zasadami

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

Testowanie

Zgłoszony błąd

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

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

Błąd nie został zgłoszony

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

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

C, 66 48

Oryginał:

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

Za pomocą gcc OSX
l("duck");zwraca 4,
l("google");powoduje Floating point exception: 8.

Na innych platformach konieczne może być dostosowanie stałych pod kątem endianizmu.

Krótszy :

mniej podstępu, te same wyniki.

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

Rubinowy, 29 bajtów

Najpierw wymyśliłem coś bardzo podobnego do pierwszej próby @ Borsunho, ale moja była nieco dłuższa i opublikował ją, zanim skończyłem. Przyszło mi to do głowy przed jego edycją 30 bajtów :)

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

Przykłady użycia:

$ 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>'

Rubin , 25 bajtów

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

Zastąpiony String#sizenowym unary plus. Wypróbuj online!

> <>, 55 bajtów

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

Pomyślałem, że spróbuję, a nie moja najlepsza próba golfa lub algorytm. Nie jest to funkcja sama w sobie, ale myślę, że nadal powinna się ona kwalifikować. Zobaczę, czy mogę edytować w lepszej wersji.

Jeśli możesz wydrukować długość, a następnie błąd, oto 46-bajtowe rozwiązanie:

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

49 bajtów poprzednie rozwiązanie tego rodzaju:

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

Z przyjemnością przedstawię wyjaśnienie, jeśli jest jakieś zainteresowanie, i daj mi znać, jeśli coś jest nie tak z moją odpowiedzią lub masz sugestie dotyczące gry w golfa.

JavaScript ES6, 51 27 25 bajtów

Cześć, jestem nowy w kodowaniu golfa, więc prawdopodobnie można grać w golfa o wiele więcej, ale oto:

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

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

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

i trochę testu:

(_=>_=="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

Edycja: Dodano? zastąpić if i zastąpić błąd niezdefiniowanym obiektem.

Edycja 2: Zorientowałem się, że moja liczba bajtów jest nieprawidłowa i usunąłem g =

GolfScript, 14 16 znaków

{.,\'google'=!/}

Podobnie jak wiele innych, po prostu porównuje dane wejściowe 'google'i dzieli długość przez odwrotność wyniku.

Przykładowe programy:

• Z'bing' (wyjście: 4)
• Z'google' (wyjście: Błąd: Próbowano podzielić przez zero ).

Utknął , 16 bajtów

s_l1u"google"=-/

Postępowanie podobne do większości osób spowoduje błąd dzielenia przez 0 przy wprowadzaniu „google”.

Pakiet Windows, 118 znaków

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

Dane wyjściowe to% stringlength%.

Pełny kod:

@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

Modyfikowany odpowiedź Joshua Honig, w tutaj .