Todos sabemos que, se você pesquisar no Google a palavra "google", ela quebrará a Internet.

Sua tarefa é criar uma função que aceite uma sequência e retorne seu comprimento, no menor número possível de caracteres Unicode.

No entanto, se a sequência especificada for google(minúscula), isso causará um erro.

Por exemplo, g('bing')retornará, 4mas g('google')causará um erro.

Forneça um exemplo de uso e o erro, se possível.

Python 2, 29

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

Dá uma ZeroDivisionErrorem "google", e o comprimento de outro modo. Isso tira vantagem dos booleanos do Python iguais a 0e 1.

Excel, 23 caracteres

Cole isso em uma célula diferente de A1 e digite sua consulta de pesquisa em A1.

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

Por exemplo:

C #, 43 bytes

Uma melhoria em relação à resposta de Salah Alami. É recorrente lançar uma exceção de estouro de pilha ao fornecer "google"

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

Pitão, 14 13 caracteres

L/lbnb"google

Define uma função nomeada y.

Isso divide o comprimento por 1 se a sequência não for google e por 0 em caso contrário. A ideia não é nova, mas a criei de forma independente.

Experimente online.

Como funciona

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 bytes

Agradecimentos a Tom Carpenter por reduzir 1 byte!

Agradecimentos a Stewie Griffin por remover 2 bytes!

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

Ao contrário das outras soluções mais elegantes, executar uma operação de divisão por zero no MATLAB não dará um erro, mas sim Inf. Esta solução encontra o comprimento da cadeia por nnz. A sequência produzida é de maneira que você indexe do início à sequência, o que é essencialmente uma cópia da sequência. No entanto, o importante é que o início de onde acessar a sequência seja produzido, verificando se a entrada é igual ou não 'google'. Caso contrário, produz um índice inicial de 1 e indexamos normalmente na string ... quando o MATLAB inicia a indexação em 1. Se for igual, o índice produzido é 0 e o MATLAB emitirá um erro de indexação informando que o O índice precisa ser um número inteiro positivo. O Extra+é garantir que a saída da verificação de igualdade seja numérica em vez de booleana / logical. A omissão do +aviso produzirá um aviso, mas como as especificações deste desafio não permitem avisos, +é necessário ... completando o código.

Exemplo de usos

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

Uma versão mais divertida, 83 77 76 74 72 bytes

Agradecimentos a Tom Carpenter por reduzir 1 byte!

Agradecimentos a Stewie Griffin por remover 2 bytes!

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

A descrição acima não é uma inscrição oficial, mas é algo mais divertido de executar. Abusando evalem funções anônimas, o que o código faz é verificar se a sequência de entrada é igual a 'google'... e, se for, isso abrirá o navegador da web incorporado do MATLAB e exibirá a página de erro 404 do Google tentando acessar o subpágina localizada em iquando isso não existe. Caso contrário, exibimos o comprimento da string normalmente.

Exemplo de usos

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

ans =

     4

>> f('google')
>> 

A última chamada usando 'google'nos fornece esta tela:

JavaScript ES6, 34 27 25 caracteres

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

Lança um ReferenceError no Δpara google.

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

TI-BASIC, 15 bytes

Heck, enquanto estamos nisso , pode muito bem obter uma resposta TI-BASIC aqui.

O formato de entrada é "string":prgmNAME. Agradecemos a Thomas Kwa por encontrá-lo primeiro!

length(Ans)+log(Ans≠"GOOGLE

(Guia: adicione 1 byte para cada letra minúscula, substituindo uma maiúscula. Então s/GOOGLE/google/g => +6 bytes.)

ahhhhh casos de teste!

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

APL (14)

(⍴÷'google'∘≢)

Explicação:

• ⍴: comprimento
• ÷: dividido por
• 'google∘≢: argumento não é igual a 'google'.

⍴fornece o comprimento da string, que é dividido por 1 se a string não for igual google(o que devolve o comprimento inalterado) ou por 0 se a string for igual google(com erro).

Python 3, 30 bytes

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

Indexa a lista de funções com 1 elemento, aumentando um IndexErrorse o u=='google'predicado é True(= 1). Tão funcional.

Muitas variantes. Uau:

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

Se o desafio for invertido (erro em tudo que não seja "google"), você poderá salvar um caractere:

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

Mas você já sabe o comprimento, então apenas o codifique.

Haskell, 24 bytes

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

Resultado:

Main> g "google"

Program error: pattern match failure: g "google"

Main> g "bing"
4

CJam, 16 caracteres

{_,\"google"=!/}

Isso divide o comprimento por 1 se a sequência não for google e por 0 em caso contrário. A ideia não é nova, mas a criei de forma independente.

Experimente online.

Como funciona

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

Oitava, 63 bytes

Eu sei que é mais longo que a solução Matlab (que também funcionaria no Octave), mas é particularmente ruim. Estou criando uma função anônima (evil) usando literais de array de células (evil) (evil) contendo identificadores de função dependentes de uma função de retorno de chamada (ela própria, portanto recursiva, evil) que deve ser transmitida por meio de argumento. Então eu crio outro anônimo que basicamente reduz a função ao argumento string e corrige o segundo argumento fcomo f(very evil). Qualquer humano são nunca faria isso, porque é quase tão ilegível quanto Perl ou regex (ou cjam / pyth / qualquer outro esolang).

Portanto, se a string não for 'google', o segundo argumento da matriz de células será chamado, o que gera o comprimento da string. Caso contrário, a primeira função será chamada, que é passada como retorno de chamada (e passa por si mesma como retorno de chamada para si mesma), que posteriormente é a própria função. O erro é basicamente algum erro de profundidade de recursão máxima.

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

JavaScript, 25 bytes

Exemplo de JavaScript simples e agradável:

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

Se "google" for inserido, ele passa um ReferenceError

Exemplo

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

APL, 19 17 bytes

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

Esta é uma função monádica sem nome que lançará um erro de sintaxe se a entrada for google. Isso é conseguido tentando adotar o logaritmo natural do nada.

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

Experimente online

Economizou dois bytes graças a Dennis!

R, 46 bytes

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

A menos que eu esteja interpretando mal, a postagem original nunca especificou que o código precisava estar com a sintaxe correta.

Exemplo:

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

Eu nunca adicionei nada para o parâmetro "no" da instrução ifelse, portanto ele retornará um erro se esse parâmetro for evocado.

Perl, 31 29 bytes

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

-2b graças ao manatwork

Uso:

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

Se eu pudesse usar um programa em vez de uma função, o seguinte seria válido com apenas 20 bytes (linha de comando de +1 byte)

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

Erro é divisão por zero.

Explicação:

y///cretorna o comprimento e !/^google$/retornará 0 se a entrada corresponder a 'google'.

Uso:

perl -p entry.pl input.txt

Haskell - 30 caracteres

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

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

Python 3, 35 bytes

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

Java 7: 53 52 bytes

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

O código acima lançará ArithmeticExceptiona divisão por zero e por qualquer Stringoutra que não seja google. Vale ressaltar que ==compara a referência e não funciona para Stringobjetos.

Java 8: 29 bytes

(Com base na sugestão dada no comentário abaixo)

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

C ++ 11, 54 (código) + 14 (#include) = 68

Bem, a divisão por zero é apenas um comportamento indefinido, que eu não chamaria de erro. Então, minha abordagem.

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

uso

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

MUMPS, 28 bytes

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

Uso:

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

<SELECT>g^MYROUTINE

Por quê? Bem, $S[ELECT]é basicamente uma declaração if-else compacta com várias cláusulas - quase como uma correspondência de padrões em uma linguagem como Haskell ou Rust. Exceto ... ao contrário de Haskell ou Rust, os padrões não são verificados quanto à exaustividade, porque a noção de "segurança em tempo de compilação" é completamente estranha ao MUMPS. Portanto, se sua entrada for um padrão que você não considerou, você receberá um erro de tempo de execução adorável <SELECT>.

Ruby, 34 30 27 26

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

Desconhecido tgera exceção.

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

Edit: versão totalmente legível e óbvia, que é mais curta ...

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

Velho: Parece muito com outras idéias. Aumentará ArgumentErrorse x for 'google'.

JavaScript, 47 bytes

Agradável e simples.

Editar: agora está em conformidade com as regras

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

Testando

Erro lançado

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

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

Nenhum erro lançado

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

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

C, 66 48

Original:

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

Usar o OSX gcc,
l("duck");retorna 4,
l("google");causa Floating point exception: 8.

Em outras plataformas, as constantes podem precisar ser ajustadas para endianness.

Mais curto :

menos truque, mesmos resultados.

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

Ruby, 29 bytes

Primeiro, criei algo muito semelhante à primeira tentativa de @ Borsunho, mas a minha era um pouco mais longa e ele postou a sua antes que eu terminasse. Veio com isso antes de seus 30 bytes editar :)

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

Exemplos de uso:

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

Ruby , 25 bytes

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

Substituído String#sizepelo novo plus unário. Experimente online!

> <>, 55 bytes

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

Achei que eu tentaria, não a minha melhor tentativa ou algoritmo de golfe. Não é uma função em si, mas acho que isso ainda deve se qualificar. Vou ver se consigo editar em uma versão melhor.

Se você pode imprimir o comprimento e depois o erro, aqui está uma solução de 46 bytes:

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

Solução anterior de 49 bytes desta natureza:

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

Fico feliz em apresentar uma explicação se houver algum interesse e informe-me se houver algo errado com minha resposta ou se você tiver sugestões de golfe.

Javascript ES6, 51 27 25 bytes

Olá, sou novo em codificar golfe, então provavelmente isso pode ser muito mais, mas aqui está:

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

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

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

e algum teste:

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

Editar: adicionado? para substituir if e substituir Error por um objeto indefinido.

Edição 2: percebi que minha contagem de bytes estava incorreta e removi g =

GolfScript, 14 16 caracteres

{.,\'google'=!/}

Como muitos outros, simplesmente compara a entrada 'google'e divide o comprimento pelo inverso do resultado.

Programas de exemplo:

• Com'bing' (saída: 4)
• With'google' (output: Error: Tentativa de dividir por zero. )

Preso , 16 bytes

s_l1u"google"=-/

Seguir um método semelhante ao da maioria das pessoas causará um erro de divisão por 0 no "google" sendo inserido.

Lote do Windows, 118 caracteres

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

A saída é% stringlength%.

Código completo:

@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

Modificado a partir da resposta de Joshua Honig, aqui .