Todos sabemos que si buscas en Google la palabra "google", romperá Internet.

Su tarea es crear una función que acepte una cadena y devuelva su longitud, en la menor cantidad posible de caracteres Unicode.

Sin embargo, si la cadena dada es google (minúscula), causará un error.

Por ejemplo, g('bing')volverá 4perog('google') causará un error.

Proporcione un ejemplo de uso y el error si es posible.

Pitón 2, 29

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

Da un ZeroDivisionErrorencendido "google"y la longitud de lo contrario. Esto aprovecha la igualación 0y el valor booleano de Python 1.

Excel, 23 caracteres

Pegue esto en una celda que no sea A1 y escriba su consulta de búsqueda en A1.

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

Por ejemplo:

C #, 43 bytes

Una mejora sobre la respuesta de Salah Alami. Se repite para lanzar una excepción de desbordamiento de pila al proporcionar "google"

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

Pyth, 14 13 caracteres

L/lbnb"google

Define una función con nombre y .

Esto divide la longitud por 1 si la cadena no es google y por 0 en caso contrario. La idea no es nueva, pero se me ocurrió de forma independiente.

Pruébalo en línea.

Cómo 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

¡Gracias a Tom Carpenter por eliminar 1 byte!

¡Gracias a Stewie Griffin por eliminar 2 bytes!

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

A diferencia de otras soluciones más elegantes, realizar una operación de división por cero en MATLAB no dará un error, sino más bien Inf. Esta solución determina que la longitud de la cadenannz . La cadena que se produce es de tal manera que se indexa desde el principio de la cadena hasta el final, que es esencialmente una copia de la cadena. Sin embargo, lo importante es que el comienzo de dónde acceder a la cadena se produce al verificar si la entrada es igual o no 'google'. Si no lo es, esto produce un índice inicial de 1 e indexamos en la cadena normalmente ... ya que MATLAB comienza a indexar en 1. Si es igual, el índice producido es 0 y MATLAB arrojará un error de indexación que indica que El índice debe ser un número entero positivo. El extra+es asegurar que la salida de la verificación de igualdad sea numérica en lugar de booleana / logical. Omitir +producirá una advertencia, pero debido a que las especificaciones de este desafío no permiten advertencias, +se requiere ... completando así el código.

Usos de ejemplo

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

Una versión más divertida, 83 77 76 74 72 bytes

¡Gracias a Tom Carpenter por eliminar 1 byte!

¡Gracias a Stewie Griffin por eliminar 2 bytes!

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

Lo anterior no es una presentación oficial, pero es algo más divertido de ejecutar. Abusando de evallas funciones anónimas, lo que hace el código es que verifica si la cadena de entrada es igual a 'google'... y si es así, esto abrirá el navegador web incorporado de MATLAB y muestra la página de error 404 de Google tratando de acceder al subpágina ubicada en icuando eso no existe. Si no, mostramos la longitud de la cadena normalmente.

Usos de ejemplo

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

ans =

     4

>> f('google')
>> 

La última llamada usando 'google'nos da esta pantalla:

JavaScript ES6, 34 27 25 caracteres

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

Lanza un error de referencia Δpara google.

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

TI-BASIC, 15 bytes

Heck, mientras lo hacemos , bien podría obtener una respuesta TI-BASIC aquí.

El formato de entrada es "string":prgmNAME. ¡Gracias a Thomas Kwa por encontrarlo primero!

length(Ans)+log(Ans≠"GOOGLE

(Guía: agregue 1 byte por cada letra minúscula reemplazando una mayúscula. Entonces s/GOOGLE/google/g => +6 bytes.)

ahhhhh casos de prueba!

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

APL (14)

(⍴÷'google'∘≢)

Explicación:

• ⍴: longitud
• ÷: dividido por
• 'google∘≢: argumento no es igual a 'google'.

⍴da la longitud de la cadena, que se divide por 1 si la cadena no es igual google(lo que devuelve la longitud sin cambios), o por 0 si la cadena es igual google(dando un error).

Python 3, 30 bytes

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

Indexa la lista de funciones de 1 elemento, generando un IndexErrorsi el u=='google'predicado es True(= 1). Tal funcional.

Muchas variantes. Guau:

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

Si el desafío fue invertido (error en todo lo que no es "google"), podría guardar un char:

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

Pero ya sabes la longitud, así que solo codifícala.

Haskell, 24 bytes

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

Salida:

Main> g "google"

Program error: pattern match failure: g "google"

Main> g "bing"
4

CJam, 16 caracteres

{_,\"google"=!/}

Esto divide la longitud por 1 si la cadena no es google y por 0 en caso contrario. La idea no es nueva, pero se me ocurrió de forma independiente.

Pruébalo en línea.

Cómo 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.

Octava, 63 bytes

Sé que es más largo que la solución de Matlab (que también funcionaría en Octave), pero es particularmente malo. Estoy haciendo una función anónima (evil) usando literales de matriz de celdas (evil) (evil) que contienen manejadores de funciones dependientes de una función de devolución de llamada (en sí misma, por lo tanto, recursiva, evil) que se debe pasar por argumento. Luego creo otro anónimo que básicamente reduce la función al argumento de cadena y arregla el segundo argumento de fas f(muy malvado). Cualquier humano sano nunca haría esto, porque es casi tan ilegible como Perl o regex (o cjam / pyth / cualquier otro esolang).

Entonces, si la cadena no es 'google', se llamará al segundo argumento de la matriz de celdas que genera la longitud de la cadena. De lo contrario, se llamará a la primera función, que se pasa como devolución de llamada (y también se pasa a sí misma como devolución de llamada), que más tarde es la función misma. El error es básicamente un error de profundidad de recursión máxima.

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

JavaScript, 25 bytes

Ejemplo de JavaScript agradable y simple:

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

Si se ingresa "google", entonces pasa un ReferenceError

Ejemplo

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

APL, 19 17 bytes

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

Esta es una función monádica sin nombre que arrojará un error de sintaxis si la entrada es google. Esto se logra al intentar tomar el logaritmo natural de la nada.

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

Pruébalo en línea

¡Ahorré dos bytes gracias a Dennis!

R, 46 bytes

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

A menos que esté leyendo mal, la publicación original nunca especificó que el código tenía que ser la sintaxis correcta.

Ejemplo:

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

Nunca agregué nada para el parámetro "no" de la instrucción ifelse, por lo que devolverá un error si se evoca este parámetro.

Perl, 31 29 bytes

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

-2b gracias a manatwork

Uso:

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

Si pudiera salir con un programa en lugar de una función, lo siguiente sería válido con solo 20 bytes (línea de comando de +1 byte)

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

El error es la división por cero.

Explicación:

y///c devuelve la longitud, luego !/^google$/ devolverá 0 si la entrada coincide con '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();} 

El código anterior arrojará la ArithmeticExceptiondivisión por cero y por cualquier Stringotro que no sea google. Vale la pena señalar que ==compara la referencia y no funcionará para StringObjetos.

Java 8: 29 bytes

(Basado en la sugerencia dada en el comentario a continuación)

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

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

Bueno, la división por cero es solo un comportamiento indefinido, que no llamaría un error. Entonces mi enfoque.

#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é? Bueno, $S[ELECT]es básicamente una declaración if-else compacta de múltiples cláusulas, casi como una coincidencia de patrones en un lenguaje como Haskell o Rust. Excepto ... a diferencia de Haskell o Rust, no se verifica la exhaustividad de los patrones, porque la noción de "seguridad en tiempo de compilación" es completamente ajena a MUMPS. Entonces, si su entrada es un patrón que no tuvo en cuenta, obtendrá un encantador error de tiempo de ejecución llamado <SELECT>.

Rubí, 34 30 27 26

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

Desconocido tplantea excepción.

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

Editar: versión totalmente legible y obvia que es más corta ...

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

Viejo: bastante similar a otras ideas, parece. ElevaráArgumentError si x es 'google'.

JavaScript, 47 bytes

Agradable y simple

Editar: ahora cumple con las reglas

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

Pruebas

Error arrojado

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

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

Ningún error arrojado

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

Usando OSX gcc,
l("duck");retornos 4,
l("google");causas Floating point exception: 8.

En otras plataformas, es posible que las constantes deban ajustarse según la resistencia.

Más corto :

menos dificultad, mismos resultados.

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

Ruby, 29 bytes

Primero se me ocurrió algo muy similar al primer intento de @ Borsunho, pero el mío fue un poco más largo y publicó el suyo antes de que terminara. Se le ocurrió esto antes de su edición de 30 bytes :)

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

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

Rubí , 25 bytes.

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

Reemplazado String#sizecon el nuevo plus unario. Pruébalo en línea!

> <>, 55 bytes

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

Sin embargo, pensé que lo intentaría, no es mi mejor intento o algoritmo de golf. No es una función per se, pero creo que esto aún debería calificar. Veré si puedo editar en una versión mejor.

Si puede imprimir la longitud y luego el error, aquí hay una solución de 46 bytes:

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

Solución previa de 49 bytes de esta naturaleza:

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

Me complace presentar una explicación si hay algún interés, y por favor avíseme si hay algún problema con mi respuesta o si tiene sugerencias de golf.

Javascript ES6, 51 27 25 bytes

Hola, soy nuevo en el código de golf, por lo que probablemente se pueda jugar mucho más, pero aquí está:

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

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

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

y alguna prueba:

(_=>_=="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: ¿Agregado? para reemplazar si y reemplazar Error con un objeto indefinido.

Edición 2: me di cuenta de que mi número de bytes estaba mal y eliminé el g =

GolfScript, 14 16 caracteres

{.,\'google'=!/}

Como muchos otros, simplemente compara la entrada 'google'y divide la longitud por el inverso del resultado.

Programas de ejemplo:

• Con'bing' (salida: 4)
• Con'google' (salida: Error: Intento de dividir entre cero ) .

Atascado , 16 Bytes

s_l1u"google"=-/

Seguir un método similar al de la mayoría de las personas provocará un error de división por 0 al ingresar "google".

Lote de Windows, 118 caracteres

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

La salida es% 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 de la respuesta de Joshua Honig, aquí .