Não pesquise no google

158

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.

rybo111
fonte
122
Eu pesquisei google e Google encontrou Google no Google. Mito rebentado.
Geobits 28/09/2015
86
@ Geobits Isso é simplesmente um teste para ver se vou pesquisar no Google, o que não vou. : D
rybo111
7
A função precisa fazer distinção entre maiúsculas e minúsculas? Deveria jogar dado 'gOOgle'?
AXMIM
2
Quando digito google no google (a barra de pesquisa no chrome), surge uma mensagem perguntando se eu queria ir ao google . (Agora que é um tld, isso faz sentido, ou seja, com.google funciona). Cliquei e recebi um erro de pesquisa de DNS. Internet: quebrado!
Craig
4
Estou votando para reabrir isso. Não vi perguntas sobre o que constitui um erro para esse desafio e ele já tem 154 respostas, então não acho justo alterar as especificações. Este pode não ser um exemplo de boa pergunta, mas é claro o suficiente. Se uma resposta realmente se resumir a se um determinado resultado é ou não um erro, provavelmente não receberá tantas votações, de qualquer maneira.
Poke

Respostas:

228

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.

xnor
fonte
2
+1. Você precisa definir gcomo lambda, ou chamá-lo anonimamente com uma entrada.
Zach Gates
4
Apenas por diversão, tentei essa técnica com JavaScript ES6. Ele terminou na 25, mas retorna Infinitypara "google" em vez de jogar um erro ...
ETHproductions
18
@ZachGates O consenso sobre a meta é que funções anônimas são permitidas, a menos que sejam especificamente proibidas. Como a pergunta parece implicar algo assim (mas ainda não a impede explicitamente), você deve perguntar ao OP sobre isso.
FryAmTheEggman 28/09/2015
3
@ Kevin você precisaria de um returnse você usoudef
FryAmTheEggman
3
Divertidamente, isso traduzido para Pyth se sai melhor do que minha melhor solução anterior de Pyth. São L/lbnb"google13 bytes.
Isaacg
107

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:

GoogleGoogle

Mão-E-Comida
fonte
9
Qual é o consenso geral sobre o uso do Excel?
Decay Beta
52
@BetaDecay. Criativo, incomum, parece funcionar. Não será aplicável a todos os quebra-cabeças de computação gráfica, mas está aqui!
Kdbanman # 30/15
119
Os gerentes adoram!
lkraider
18
Tão eficientes que os usuários de CG o odeiam por isso. Mas espere. B3 mudará sua vida para sempre!
Sumurai8
8
Qual é o consenso específico sobre o uso do Excel?
GreenAsJade
81

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);
DLeh
fonte
2
Sim, eu pensei que era uma maneira muito inteligente de salvar alguns personagens para lançar uma exceção. Com 4 caracteres, pode ser a menor maneira de lançar uma exceção em C #, não tenho certeza.
DLeh
6
Isso é inteligente! No entanto, versões recentes do C # têm suporte para recursão de cauda, portanto, essa função nunca será lançada StackOverflowException. Na verdade, ele nunca retornará (se comporta como while(true){}).
NightElfik
2
As chamadas de recursão @DLeh Tail são um pouco complicadas. Você precisa executar o JIT x64 e sem o depurador (o depurador anexado fará com que a recursão da cauda não funcione por motivos óbvios). Aqui está o meu programa como uma prova: imgur.com/ErNl8LJ e pouco mais leitura sobre recursão de cauda: blogs.msdn.com/b/davbr/archive/2007/06/20/... ;)
NightElfik
12
Haha: g (string) ... eu vou me ver fora ...
gregsdennis
1
@DLeh oh espera não, eu posso combinar seus 43 bytes, mas não vencê-lo. :) int g (string s) => s! = "google"? s.Length: s [9];
lee
57

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)
Dennis
fonte
Sim, na verdade não tenho certeza disso, acho que isso nunca aconteceu antes com uma corda. Normalmente, você pode fechá-lo com ;mas, obviamente, você não pode aqui ...
FryAmTheEggman
Você não precisa da cotação final.
Maltysen 28/09/2015
48
" Define uma função nomeada y. " Mas não há yno seu código !?
AL
46
@AL Isso está correto. O interno Lredefine a função y.
Dennis
90
Não tenho certeza, mas acho que odeio Pyth.
Mr Lister
40

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:

insira a descrição da imagem aqui

rayryeng
fonte
3
Você pode salvar um byte usando em strcmpvez de isequal.
Tom Carpenter
@TomCarpenter - Funny. Na verdade, eu disse a mim mesma para usar, strcmpmas acabei usando isequalpor algum motivo .... obrigado!
rayryeng
1
nnzé dois bytes menor que numel. Você teve meu voto há alguns anos atrás :-)
Stewie Griffin
31

JavaScript ES6, 34 27 25 caracteres

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

Lança um ReferenceError no Δpara google.

Jonathan
fonte
10
Você pode usar um operador ternário para salvar dois bytes.
21915 Konrad Borowski
2
Sim, isso é exatamente o que eu acabei de receber. Se você quiser ser chique, use um símbolo que as pessoas nunca usam em vez de g para garantir que ele não exista como uma variável global. Δ cria um bom nome de variável :)
Domino
1
Você pode usar #, ele erros em JS afaik
aplauso
7
Δ Google Illuminati confirmado
DynamiteReed
2
Eu só vou deixar isso aqui github.com/Rabrennie/anything.js
sagiksp 9/17
26

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
Conor O'Brien
fonte
20 bytes: length(Ans)/(Ans≠"google. Você também está com o caso errado; se maiúsculas são permitidas, são 14 bytes. A propósito, é válido passar argumentos pelos Ans.
precisa saber é o seguinte
AGOOGLEdeve dar 7, correto? E você não deve contar o cabeçalho do programa no tamanho do seu código, portanto subtraia 10 bytes.
lirtosiast
ERRO: Eu estava pensando em substrings. Por favor, me perdoe.
Conor O'Brien
1
@ThomasKwa Não vi seu comentário com o código. Acontece que nós dois encontramos a mesma solução. No entanto, se você acredita que merece o crédito, o crédito será seu. ^ _ ^ ( EDIT Se você ler o código, não é exatamente a mesma coisa.)
Conor O'Brien
@lirtosiast length(tem dois bytes, isso tornaria seus números 21 e 15 bytes.
Timtech 29/03/16
23

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

marinus
fonte
11
Eu acho que você não precisa contar os parênteses, pois eles podem ser atribuídos a uma variável sem eles.
precisa saber é o seguinte
O tipo de falha em argumentos de caractere único. Corrija substituindo por . Além disso, você pode ter uma aparência mais interessante trocando os operandos de . Ah, não esqueça de remover os parênteses. Tudo em tudo:≢÷≢∘'google'
Adám
21

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.

Nick T
fonte
trabalha para Python 2.7 também
Noodle9
Por alguma razão, eu amo essa solução.
foslock
19

Haskell, 24 bytes

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

Resultado:

Main> g "google"

Program error: pattern match failure: g "google"

Main> g "bing"
4
chs
fonte
15

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.
Dennis
fonte
Curiosamente, um programa completo é mais curtos (15 bytes): q_,\"google"=!/. Desenvolvi antes de ver este post. Observe que isso recebe toda a entrada (que você parece usar como argumento de função). Infelizmente, você não pode usá-lo, pois isso solicita uma função :(
Erik the Outgolfer 1/16/16
15

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)
ಠ_ಠ
fonte
2
Essas coisas não são más na maioria das línguas. E este é o código de golfe, alguns dos códigos mais ilegíveis do planeta existem aqui :). Alça fria btw.
BAR
9
Eu só estou faltando alguma evalaqui para torná-lo :-) realmente MAL
Luis Mendo
12

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

GeoffWilson
fonte
2
Uau, obrigado por me dizer que há uma abreviação de funções lamda em javascript!
Tomáš Zato
3
@ TomášZato Caveat: eles são novos no ES2015 , então o suporte ainda varia.
Anko4 /
11

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!

Alex A.
fonte
é conhecido informalmente como "splat". Um nome muito apropriado para esse uso.
Adám
9

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.

syntonicC
fonte
10
Aqui está um pouco mais curto:g=function(x)nchar(x)[[x!="google"]]
flodel
9

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
Jarmex
fonte
2
Você poderia torná-lo uma função anônima: sub{…}. (Então você chama assim sub{…}->("google")).
manatwork
Salve 1 byte usando $_!=googleem vez de!/^google$/
Gabriel Benamy
@GabrielBenamy Receio !=que não funcione para comparar as strings ... #
Dada
7

Haskell - 30 caracteres

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

>g "google"
 *Exception: !
>g "str"
 3
C. Quilley
fonte
6
Por que o ponto de exclamação por erro? Uma string vazia também não seria?
Kritzefitz 28/09
1
Eu queria sugerir alterá-lo para x=x;g"google"=x;g s=length s, mas por algum motivo, as <<loop>> exceções não são lançadas no ghci.
Kritzefitz
17
g s|s/="google"=length sevita a necessidade deerror
chs
7

Python 3, 35 bytes

lambda n:len(n)if n!='google'else d
Zach Gates
fonte
1
@FryAmTheEggman na verdade 16 bits mais curto. XD
DiegoDD 28/09
1
@FryAmTheEggman: Bom truque, mas o id não funciona com a cadeia de caracteres vazia:(lambda n:len(n)*(n!='google')or d)('')
pabouk
@pabouk Muito bem, obrigado por apontar isso.
FryAmTheEggman 29/09/2015
7

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()
CoderCroc
fonte
1
Você também pode usar a declaração lambda do Java 8:s->(s.equals("google")?null:s).length();
hjk
3
"Vale ressaltar que == compara a referência e não funciona para objetos String." Na verdade, todas as strings são objetos, portanto, comparar strings com ==Java geralmente não funcionará (a menos que você esteja contando com a internação de strings, o que é muito ruim). Talvez você tenha se confundido com JavaScript?
gengkev
1
@gengkev Se os dois forem literais, funcionará, pois é o mesmo objeto que é mencionado no pool String. A especificação fornece um literal e aqui está um literal, para que funcione.
Yassin Hajaj
2
@YassinHajaj Eu concordo que a especificação o fornece como literal, mas isso é apenas um exemplo. A função provavelmente deve executar o mesmo se for fornecida também a entrada de stdin, ou se a função for chamada de outra classe que é compilada separadamente. De qualquer forma, confiar nas otimizações do compilador (cadeia de caracteres interna) é uma péssima idéia, que foi o que eu disse originalmente.
21715 Gengkev
7

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");
Zereges
fonte
1
Você pode ligar size()para salvar 2 bytes. No C ++ 14, você também pode usar lambdas genéricas e substituir std::stringpor auto. Você precisaria passar um real std::stringpara ele em vez de um const char*.
Isanae 28/09/2015
@isanae eu não sabia que std::stringtem size()método, obrigado por isso. Estou ciente das lambdas genéricas no C ++ 14, mas não sei como isso me ajudaria, pois "string"é const char*e não std::string.
Zereges
1
O @Zereges std::stringtem size()e length()porque é um contêiner e uma string . Quanto a auto, você chamaria o lambda com em (std::string("google"))vez de ("google"). A pergunta diz apenas "aceita 1 string" sem especificar o que é uma "string".
Isanae 29/09/2015
@isanae C ++ 14 também tem "google"sa construir um std::string:)
Quentin
@ Zereges você pode simplesmente throw;acionar std::terminate()(porque não há nenhuma exceção atual aqui).
Quentin
6

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

senshin
fonte
6

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

Borsunho
fonte
2
Por que esses parênteses? x=='google'?t: x.size
manatwork
6

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

Beta Decay
fonte
Tecnicamente, isso não atende às especificações do OP. Esta função alerta o comprimento, mas retorna undefined.
Bungle
@Bungle Como está agora?
Beta Decay
1
@Bungle eu vejo. Eu esqueci que era necessário um retorno
Decay Beta
1
Usando funções de seta do ES6 e operador ternário (em vez de se), você pode espremer que um pouco mais :)
Carles Alcolea
1
@BetaDecay Originalidade em primeiro lugar; Eu respeito isso.
Carles Alcolea
6

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");}
AShelly
fonte
Uau, essa é uma lógica interessante lá. Se eu entendi direito a parte do golfe, você está, de alguma forma, alterando os seis primeiros caracteres para que se encaixem em um único número gigante (quase como um hash), que, por causa da pilha ser pouco endian, acaba sendo "google", mas para trás ( 0x656c676f6f67= elgoog). Acho que essa resposta precisa de uma explicação para quem aprecia esse tipo de coisa louca de baixo nível.
Braden Best
Você basicamente tem. Simplesmente lança a memória armazenando a string em um número de 64 bits. Endianness torna o processo "atrasado" nas arquiteturas x86. O texto ocupa apenas 7 bytes, portanto a máscara apenas oculta o que quer que seja o próximo na memória. É um truque divertido, mas acho que '!! strcmp (s, "google")' é realmente mais curto.
ASHelly #
1
De qualquer forma, +1. Definitivamente. Além disso, acho que você pode reduzi-lo removendo os int 4 caracteres.
Braden Best
Depois de digitar , eu descobri! Se char *, com unidades de 8-bits, for convertido para long *, com unidades de 64-bits, sem ser realocado corretamente, os dados nesses 8 bytes de espaço de heap serão corrompidos e tratados como um número único ( 8*8 = 64). É por isso que você recebe os 6 primeiros caracteres, + NUL + lixo. Isso é muito inteligente. Perigoso também. Me pergunto por que não falha. Esse oitavo byte de lixo está fora dos limites, não?
Braden Best
Eu olhei para a sua análise. Você está correto, a mudança deveria ter sido 56, não 54. Além disso, eu não usaria a palavra corrompida. A memória é a mesma, os bits são apenas interpretados de maneira diferente. Tecnicamente, o acesso ao byte de lixo é um comportamento indefinido e pode, na verdade, ser falhado. Praticamente, esse byte quase certamente reside no mesmo bloco de memória legal que o restante da cadeia e, geralmente, esses blocos (pilha, pilha, constantes) são alocados no mínimo em unidades de tamanho de palavra. Portanto, a memória pertence ao programa, apenas contém algo diferente da string.
AShelly
6

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

edit: Dois anos e algumas versões do Ruby mais tarde

Ruby , 25 bytes

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

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

daniero
fonte
Legal, eu não consegui fazer isso funcionar (não pensei em sair de ^fora do grupo).
Borsunho
@ Borsunho Eu tenho que admitir que eu apenas "brutalmente forcei" a regex até que eu tenha o resultado que eu queria :) Eu acho que .*no final é o que a faz funcionar.
Daniero 28/09/2015
Quebra se a sequência de entrada possui várias linhas e contém o google em sua própria linha. Eu acho que /\A(?!google\Z).*/mcorrige (ao custo de três bytes, no entanto). ^e $coincidir com o início e o fim das linhas, enquanto \Ae \Zcoincidir com o início e o fim da sequência como um todo.
histocrat 28/09/2015
@histocrat mas eu não acho que você pode google cordas com várias linhas;)
daniero
4

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

Cole
fonte
4

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 =

Usuário genérico
fonte
4

GolfScript, 14 16 caracteres

{.,\'google'=!/}

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

Programas de exemplo:

pswg
fonte
@ Dennis Entendo o seu ponto. Na sua forma original, não era exatamente reutilizável (você não pode, por exemplo, aplicar o código em uma lista). Também não percebi que você havia escrito uma resposta praticamente idêntica no CJam bem antes de eu postar isso (na verdade, eu só estava vagamente ciente do CJam como idioma até agora). +1 para sua solução também.
PSWG
4

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.

Kade
fonte
4

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 .

Shane Smiskol
fonte