Russianify entusiastamente una cadena


57

Muchos de ustedes pueden haber interactuado con personas de Rusia en Internet en algún momento, y un subconjunto de ustedes puede haber notado el método un poco extraño que tienen para expresarse.

p.ej удали игру нуб)))

donde )))se agregan para enfatizar la afirmación anterior, he estado trabajando en una teoría de que la relación de )'s con el resto de la cadena es directamente proporcional a la cantidad de énfasis implícito, sin embargo, a menudo me resulta difícil calcular la relación sobre la marcha, ya que también estoy tratando de hacer frente a una gran cantidad de abusos, por lo que me gustaría que el código más corto posible me ayudara a calcular cuál debería ser la cadena resultante, por un valor de entusiasmo entre 0 y 500%, dado el original , una cadena poco entusiasta, esto ayudará mucho a mi investigación, ya que no tendré que escribir scripts voluminosos cada vez que desee probar mi hipótesis.

Entonces, el desafío:

escribir un programa o función completa que, con dos argumentos, una cadena de longitud desconocida y un número, en formato entero (entre 0 y 500) o en formato decimal (entre 0 y 5, con 2 puntos de precisión)

  • retorno / mostrar la cadena original, con el sufijo con un número de )'s
  • el número se calculará como una relación entre el número de entrada y la longitud de la cadena.
  • así que si se proporcionó el número 200, o 2.00, el 200% de la cadena debe tener el sufijo )'s
  • el número de corchetes redondeados en situaciones decimales no importa.
  • Se requiere un script para admitir caracteres ASCII imprimibles.
  • solo tiene que admitir un formato de número de entrada, de su elección.

Ejemplos:

"codegolf" 125      = codegolf))))))))))
"codegolf" 75       = codegolf))))))
"noob team omg" 0.5 = noob team omg))))))
"hi!" 4.99          = hi!)))))))))))))))

Código de ejemplo (PowerShell) (con entrada decimal):

Function Get-RussianString ([string]$InputStr,[decimal]$Ratio){
    $StrLen = $InputStr.Length
    $SuffixCount = $StrLen * $Ratio
    $Suffix = [string]::New(")",$SuffixCount)
    return $InputStr + $Suffix
}

Get-RussianString "codegolf" 0.5
codegolf))))

Este es el código más corto gana!


2
Estoy confundido, ¿los rusos realmente usan el )énfasis como un !? ¿Es algún problema de codificación?
Capitán Man

2
@CaptainMan Creo que es más como caras sonrientes que !s, pero las escriben como están, no es muy común, pero es bastante icónico.
colsw

30
@CaptainMan No )es un emoticón reducido :). Se usa muy comúnmente entre los jóvenes hasta donde yo sé.
talex

44
)No es un énfasis, es simplemente el smiley. Hasta donde sé, es más difícil escribir :cuando se usa la distribución del teclado ruso, por lo tanto, sonríen sin ojos.
Džuris

18
@Juris es tan difícil escribir :en un diseño ruso (ЙЦУКЕН) como escribir ^en QWERTY. Pero, de hecho, )es una versión reducida de :). Es mucho más fácil mantener presionado Shift-0 que alternar teclas repetidamente.
Ruslan

Respuestas:


16

Jalea , 7 bytes

ȮL×Ċ”)x

Pruébalo en línea!

Utiliza el formato decimal.

¿Cómo?

ȮL×Ċ”)x - Main link: string, decimal
Ȯ       - print string
 L      - length(string)
  ×     - multiply by the decimal
   Ċ    - ceiling (since rounding method is flexible)
    ”)  - a ')' character
      x - repeated that many times
        - implicit print

@ConnorLSW Acabo de notar que esto imprimirá la cadena requerida como un programa completo, pero que la especificación dice "retorno" - ¿está bien?
Jonathan Allan


no se preocupe, este es mi primer desafío, así que hay algunas de estas cosas que me perdí, lo actualicé en la pregunta para que sea más claro, gracias por preguntar.
colsw


16

Lisp común, 59 52 50

Paréntesis? Estoy en.

(lambda(s n)(format()"~a~v@{)~}"s(*(length s)n)0))

Detalles

(lambda(s n)               ; two arguments (string and ratio)
  (format ()               ; format as string
          "~a~v@{)~}"      ; control string (see below)
          s                ; first argument (string)
          (* (length s) n) ; second argument (number of parens)
          0))              ; one more element, the value does not matter

Cadena de control de formato

  • ~a : argumento de impresión bonita (aquí la cadena dada)
  • ~v@{...~}: bloque de iteración, limitado a la iteración V, donde V se toma como argumento, es decir, la (* ...)expresión. Se supone que la iteración itera sobre una lista, pero cuando agrega el @modificador, la lista es la lista restante de argumentos a la función de formato. Debe haber al menos un elemento en la lista iterada (de lo contrario, salimos, sin tener en cuenta V). Es por eso que hay un argumento adicional para formatear (0).

Dado que el formato no consume ningún elemento de la lista, el bucle es infinito pero, afortunadamente, también está limitado por V, también conocido como el número de paréntesis que se imprimirán.


Editar: gracias a Michael Vehrs por señalar que no hay necesidad de redondear el argumento numérico (la pregunta permite truncar / redondear como queramos, por lo que el comportamiento predeterminado funciona aquí).


12
(()) / 10 paréntesis insuficientes
BgrWorker

¿Quién pensó que este idioma es una buena idea?
downrep_nation

El esquema formatacepta un argumento decimal para v. ¿Quizás Common Lisp's también?
Michael Vehrs

@MichaelVehrs De hecho, muchas gracias.
coredump

1
@coredump En realidad, debería haber dicho "Guile's formatacepta ...", ya que el Esquema estándar formatno es compatible ~r; y Guile's formatsigue el ejemplo de Common Lisp's.
Michael Vehrs

9

JavaScript ES6, 38 31 30 bytes

s=>n=>s+')'.repeat(s.length*n)

f=s=>n=>s+')'.repeat(s.length*n)

console.log(f("hi!")(4.99))


1
Bien, creo que es lo más corto posible. Puede guardar un byte con curry: s=>n=>s+')'.repeat(s.length*n)(luego se llamaría así f("hi!")(4.99))
ETHproductions


7

05AB1E , 9 8 bytes

g*ï')×¹ì

Pruébalo en línea!

g*       # Length, multiplied by emphasis.
  ï')×   # Covnerted to an integer, push that many parenthesis.
      ¹ì # Prepend original string.

Funciona tanto para entero como decimal, orden de argumentos: f(String, Double)


-1 en la nueva versión de 05AB1E , donde ïse realiza implícitamente ×con argumento flotante.
Kevin Cruijssen

Y aquí hay un 7-byter que funciona en el 05AB1E moderno y heredado: sg * F ') « .
Grimmy


7

Pyth, 8 bytes

*\)s*lpz

¡Prueba en línea! Primero toma la proporción de emoción, luego la cuerda de la que debe entusiasmarse.

Explicación:

      pz  print out the enthused string
     l    ... and get its length
    *...Q multiply that by the ratio
   s      floor to get an integer, let's call this S
 \)       single-character string ")"
* ")" S   multiply that integer by the string, which gives a string of )s of length S.
          implicitly print that string of S )s.


5

R, 62 46 42 bytes

Función anónima que toma cadenas ay decimales n, imprime la salida en stdout.

pryr::f(cat(a,rep(")",n*nchar(a)),sep=""))

4

Pyth, 9 bytes

*s*lpzE")

Toma dos líneas de entrada: cadena y relación (decimal).

Pruébalo en pyth.herokuapp.com

Explicación

Adenota el primer argumento de una función, Bsu segundo argumento.

*s*lpzE")
    pz     # print the input string
   lAA     # take the length of the printed string
      E    # read the next line of input (the emphasis ratio)
  *AAAB    # multiply the length by the ratio
 sAAAAA    # floor the result
*AAAAAA")  # repeat ")" n times
           # implicit print

4

TI-Basic, 33 bytes

Toma entrada decimal.

Prompt Str1,A
")
For(I,0,9
Ans+Ans
End
Str1+sub(Ans,1,AI


3

CJam , 9 bytes

l_,ld*')*

Pruébalo en línea!

Cadena de entrada en la primera línea, relación de énfasis en el rango de 0 a 5 en la segunda.

Explicación

l    e# Read input string.
_,   e# Duplicate, get length.
ld   e# Read emphasis ratio.
*    e# Multiply by length.
')*  e# Get that many parentheses.

3

MATL, 11 10 8 bytes

yn*:"41h

Esta solución usa la forma decimal de la segunda entrada

Pruébalo en línea!

Explicación

        % Implicitly grab first input as a string
        % Implicitly grab the second input as a number
y       % Make a copy of the first input
n       % Compute the length of the string
*       % Multiply the decimal by the length to determine the # of )'s (N)
:       % Create the array [1...N]
"       % For each element in this array
  41    % Push 41 to the stack (ACSII for ")")
  h     % Horizontally concatenate this with the current string
        % Implicit end of for loop and display

3

sB ~, 17 bytes

i\,N?\;')'*(N*l(\

Explicado:

i\,N    input a string and a number
?\;     print the string
')'*    also print ) multiplied by...
(N*l(\  the number times the string length.

Los paréntesis se cierran automáticamente.

Aquí está la salida del compilador, si está interesado:

 INPUT  S$ ,N? S$ ;")"*(N* LEN(  S$ ))

Esta versión del compilador se escribió el 27/01/2017 a las 11:12 p.m., lo que podría haber sido unos minutos después de que se publicara esta pregunta. Aquí hay una versión que funciona en la versión más antigua del compilador, escrita una hora antes: iS$,N?S$;')'*(N*l(S$))(22 bytes)


3

PostgreSQL, 102 bytes

create function q(text,int)returns text as $$select rpad($1,(100+$2)*length($1)/100,')')$$language sql

Detalles

Utiliza el formato de entrada entero.

Esto simplemente rellena a la derecha la cadena de entrada con parens a la longitud objetivo.

create function q(text,int)
returns text as $$
    select rpad($1,             -- Pad the string input
        (100 + $2) *            -- to 100 + int input % ...
        length($1) / 100,       -- ...of the input string
        ')')                    -- with ) characters
$$ language sql

Llamado con

select q('codegolf', 125), q('codegolf', 75);
select q('noob team omg', 50), q('hi!', 499);


2

Groovy, 27 bytes

Solución directa

{s,r->s+')'*(s.length()*r)}

Programa de prueba :

def f = {s,r->s+')'*(s.length()*r)}

println f("hi!", 4.99)
println f("noob team omg", 0.5)


2

Clojure, 40 bytes

Solución bastante aburrida:

#(reduce str %(repeat(*(count %)%2)")"))

Simplemente reduce la strfunción en una lista de paréntesis de cierre con una cadena como parámetro inicial.

Véalo en línea: https://ideone.com/5jEgWS

Solución no tan aburrida (64 bytes):

#(.replace(str(nth(iterate list(symbol %))(*(count %)%2)))"(""")

Convierte la cadena de entrada a un símbolo (para deshacerse de las cotizaciones) y en repetidas ocasiones se aplica la función listen él generando secuencia infinita de esta manera: (a (a) ((a)) (((a))) ... ). El nthelemento Takes lo convierte en cadena y reemplaza todos los paréntesis de apertura por nada.

Véalo en línea: https://ideone.com/C8JmaU


1
#(.replaceAll(str(nth(iterate list %)(*(count %)%2)))"[(\"]""")1 byte menos (yay) Quería compilar pero no puedo obtenerlo por debajo de 70 bytes.
Michael M

Puede cambiar ")"a \)para guardar un byte.
clismique

2

SimpleTemplate, 92 bytes

Toma la cadena como el primer parámetro y la "relación" como el segundo.
La relación es entre 0 y 5, con 2 decimales.

{@echoargv.0}{@callstrlen intoL argv.0}{@set*Y argv.1,L}{@callstr_repeat intoO")",Y}{@echoO}

Como puede ver, no es óptimo.
El 2 {echo}podría reducirse a 1.
Debido a un error en el compilador, este código no puede reducirse mucho más.


Sin golf:

{@echo argv.0}
{@call strlen into length argv.0}
{@set* ratio argv.1, length}
{@call str_repeat into parenthesis ")", ratio}
{@echo parenthesis}

Si no existiera ningún error, el código se vería así, 86 bytes:

{@callstrlen intoL argv.0}{@set*Y argv.1,L}{@callstr_repeat intoO")",Y}{@echoargv.0,O}

2

C # interactivo, 77 67 bytes

string r(string s,int p)=>s+new string(')',(int)(s.Length*p/100d));

C # interactivo es dulce.


1
Si está utilizando C # Interactive que necesita estar en el encabezado, de lo contrario, en C #, debe incluir using System;o calificar completamente Math. Además, no estoy seguro de si puede hacerlo en forma interactiva, pero podría compilar a a Func<string, Func<int, string>>para guardar bytes, es decirs=>p=>s+new...
TheLethalCoder

1
Además, es probable que no necesite la llamada para Math.RoundintFloorFloorCeiling
enviar

1

SmileBASIC, 29 bytes

INPUT S$,N?S$;")"*(LEN(S$)*N)

dado que 3*4.99= 14.97, solo 14o 15sería aceptable como respuesta, la versión de 29 bytes debería funcionar bien, lo siento.
colsw

1

Gol> <> (Golfish), 17 bytes

i:a=?v
R*Il~/Hr)`

Pruébalo aquí .

La línea superior lee los caracteres ( i) hasta que encuentra una nueva línea (ASCII 10, a), luego baja ( v).

Luego descartamos un carácter (la nueva línea) con ~, empujamos la longitud de la pila ( l), leemos un float ( I), multiplicamos los dos y repetidamente ( R) empujamos el carácter ")" tantas veces. Finalmente, invierta la pila ( r), envíela y detenga ( H).


1

PHP, 50 bytes

<?=str_pad($s=$argv[1],strlen($s)*++$argv[2],")");

toma una cadena y un número decimal como argumentos de la línea de comando; Corta el acolchado. Correr con -r;

Descompostura

<?=                     // print ...
str_pad(                    // pad
    $s=$argv[1],            // string=argument 1
    strlen($s)*++$argv[2],  // to string length*(1+argument 2) 
    ")"                     // using ")" as padding string
);

1

Rubí, 25 bytes

->(s,n){s+')'*(s.size*n)}

Estoy usando lambdas . El programa de prueba sería algo como:

f=->(s,n){s+')'*(s.size*n)}
f.("codegolf", 1.5)        # => "codegolf))))))))))))"
f.("hi!", 4.99)            # => "hi!))))))))))))))"

1

Clojure, 68 bytes

Una función anónima que acepta entrada decimal.

(fn [s n] (print (str s (reduce str (repeat (* n (count s)) ")")))))

¡Literalmente el primer programa Lisp que he escrito! Ya me estoy divirtiendo


¡Bienvenido al mundo de Lisp! : P En Clojure, puede usar la forma condensada de funciones anónimas #(...), y puede deshacerse de ellas print(ya que los retornos de funciones deberían ser aceptables). Puede cambiar reducea applypara la strfunción, y puede cambiar ")"a \), que hace lo mismo. Por lo tanto, el código final debe ser: #(str %(apply str(repeat(*(count %)%2)\))))).
clismique

Además, el estado actual de su código no funciona, (#(...) "codegolf" 125)debe agregar 125 por ciento de la longitud de "codegolf" en lugar de 125 veces la longitud de "codegolf". Entonces, el programa fijo sería:, #(str %(apply str(repeat(*(count %)%2 1/100)\))))que es de 49 bytes.
clismique

1

C ++ 14, 43 bytes

Como lambda sin nombre que modifica su entrada, se supone que ses similar a std::string(has .append(int,char)y se supone pque es del tipo de coma flotante:

[](auto&s,auto p){s.append(s.size()*p,41);}

Uso:

#include<string>
#include<iostream>

auto f=
[](auto&s,auto p){s.append(s.size()*p,41);}
;


int main() {
 std::string s = "abcdefghijk";
 f(s,0.75);
 std::cout << s << std::endl;
}

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.