Entusiasticamente russifica uma string


57

Muitos de vocês podem ter interagido com pessoas da Rússia na internet em algum momento, e um subconjunto de vocês deve ter notado o método um pouco estranho que eles têm para se expressar.

por exemplo удали игру нуб)))

onde )))são adicionados para enfatizar a declaração anterior, tenho trabalhado em uma teoria de que a proporção de )s para o restante da string é diretamente proporcional à quantidade de ênfase implícita; no entanto, muitas vezes acho difícil calcular a proporção em tempo real, como também estou tentando lidar com uma série de abusos, então eu gostaria que o código mais curto possível me ajudasse a calcular qual deveria ser a sequência resultante, para um valor de entusiasmo entre 0 e 500%, dado o original , seqüência sem entusiasmo, isso ajudará muito minha pesquisa, pois não precisarei digitar scripts volumosos toda vez que desejar testar minha hipótese.

Então, o desafio:

escreva um programa ou função completo que, desde dois argumentos, uma sequência de comprimento desconhecido e um número, seja no formato inteiro (entre 0 e 500) ou no formato decimal (entre 0 e 5, com 2 pontos de precisão)

  • retorno / exibir a string original, seguida de uma série de )'s
  • o número será calculado como uma proporção do número de entrada para o comprimento da string.
  • portanto, se o número 200 ou 2,00 foi fornecido, 200% da string deve ser sufixado como )'s
  • o número de parênteses arredondados para situações decimais não importa.
  • É necessário um script para suportar caracteres ASCII imprimíveis.
  • só precisa suportar um formato de número de entrada, de sua escolha.

Exemplos:

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

Código de exemplo (PowerShell) (com 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))))

Isso é então o código mais curto vence!


2
Estou confuso, os russos realmente usam )para enfatizar como um !? É algum problema de codificação?
Capitão Man

2
@CaptainMan Eu acredito que é mais como carinhas do que !s, mas eles as digitam como estão, não é super comum, mas é bastante icônico.
colsw

30
@CaptainMan No )é um emoticon reduzido :). É muito comum entre os jovens, tanto quanto eu sei.
TAlex

4
)não é uma ênfase, é simplesmente o smiley. Tanto quanto eu sei, é mais difícil digitar :ao usar o layout do teclado russo, portanto eles sorriem sem olhos.
Džuris 30/01

18
@Juris, é tão difícil escrever :no layout russo (ЕНКЕН) quanto digitar ^no QWERTY. Mas, de fato, o )é uma versão reduzida do :). É muito mais fácil pressionar e manter pressionada a tecla Shift-0 do que com as teclas alternadamente repetidas.
Ruslan

Respostas:


16

Geléia , 7 bytes

ȮL×Ċ”)x

Experimente online!

Usa o formato decimal.

Quão?

Ȯ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 Acabei de notar que isso imprimirá a string necessária como um programa completo, mas que a especificação indica "return" - isso está OK?
Jonathan Allan


não se preocupe - este é o meu primeiro desafio, por isso há algumas dessas coisas que eu perdi, atualizei na questão para ficar mais claro - obrigado por perguntar.
colsw

17

Perl 6, 21 bytes

{$^a~")"x$^b*$a.comb}

16

Lisp comum, 59 52 50.

Parênteses? Eu estou dentro

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

Detalhes

(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

Cadeia de controle de formato

  • ~a : argumento de impressão bonita (aqui a string especificada)
  • ~v@{...~}: bloco de iteração, limitado à iteração V, onde V é tomado como argumento, a (* ...)expressão. A iteração deve iterar sobre uma lista, mas quando você adiciona o @modificador, a lista é a lista restante de argumentos para a função de formato. Deve haver pelo menos um elemento na lista iterada (caso contrário, sairemos, desconsiderando V). É por isso que existe um argumento adicional para formatar (0).

Como nenhum elemento da lista é consumido pelo formato, o loop é infinito, mas felizmente também é limitado por V, também conhecido como número de parênteses a serem impressos.


Edit: obrigado a Michael Vehrs por apontar que não há necessidade de arredondar o argumento numérico (a pergunta permite truncar / arredondar como quisermos, portanto o comportamento padrão funciona aqui).


12
(()) / 10 parênteses insuficientes
BgrWorker 31/01

Quem achou essa linguagem uma boa ideia?
downrep_nation

O esquema formataceita um argumento decimal para v. Talvez o Common Lisp's também?
Michael Vehrs

@MichaelVehrs De fato, muito obrigado.
Coredump

11
@coredump Na verdade, eu deveria ter dito "O Guile formataceita ...", já que o esquema padrão formatnão suporta ~r; e Guile formatsegue o exemplo do Common Lisp.
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))


11
Bom, acho que é o mais curto possível. Você pode salvar um byte através currying: s=>n=>s+')'.repeat(s.length*n)(seria, então, ser chamado assim f("hi!")(4.99))
ETHproductions


7

05AB1E , 9 8 bytes

g*ï')×¹ì

Experimente online!

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

Funciona para números inteiros e decimais, ordem dos argumentos: f(String, Double)


-1 na nova versão do 05AB1E , em que isso ïé feito implicitamente para ×com o argumento float.
Kevin Cruijssen 30/09

E aqui está um 7-byter que funciona em 05AB1E legado e moderno: sg * F ') « .
Grimmy 30/09


7

Pitão, 8 bytes

*\)s*lpz

Teste Online! Toma primeiro a razão de excitação, depois a corda para se entusiasmar.

Explicação:

      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

Função anônima que recebe string ae decimal n, imprime a saída em stdout.

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

4

Pitão, 9 bytes

*s*lpzE")

Toma duas linhas de entrada: sequência e proporção (decimal).

Experimente em pyth.herokuapp.com

Explicação

Adenota o primeiro argumento de uma função, Bseu 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*')*

Experimente online!

Insira a string na primeira linha, a taxa de ênfase no intervalo de 0 a 5 na segunda.

Explicação

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 solução usa a forma decimal da segunda entrada

Experimente online!

Explicação

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

Parênteses são fechados automaticamente

Aqui está a saída do compilador, se você estiver interessado:

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

Esta versão do compilador foi escrita em 27/01/2017 às 23:12, o que pode ter ocorrido alguns minutos após a publicação desta pergunta. Então, aqui está uma versão que funciona na versão mais antiga do compilador, escrita uma 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

Detalhes

Usa o formato de entrada inteira.

Isso simplesmente acerta a seqüência de entrada com o tamanho do alvo.

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

Chamado com

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


2

Groovy, 27 bytes

Solução simples

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

Programa de teste:

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

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

2

Rebol, 39 bytes

func[a b][append/dup a")"b * length? a]

2

Clojure, 40 bytes

Solução bastante chata:

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

Apenas reduz a strfunção em uma lista de parênteses de fechamento com uma string como parâmetro inicial.

Veja on-line: https://ideone.com/5jEgWS

Solução não tão chata (64 bytes):

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

Converte uma cadeia de entrada para um símbolo (para se livrar de aspas) e repetidamente aplica a função listnele gerando sequência infinita como este: (a (a) ((a)) (((a))) ... ). O nthelemento Takes converte-o em string e substitui todos os parênteses de abertura por nada.

Veja on-line: https://ideone.com/C8JmaU


11
#(.replaceAll(str(nth(iterate list %)(*(count %)%2)))"[(\"]""")1 byte a menos (yay). Eu queria fazer comp, mas não consigo obtê-lo abaixo de 70 bytes.
Michael M

Você pode mudar ")"para \)salvar um byte.
Clismique 5/05

2

SimpleTemplate, 92 bytes

Leva a string como o primeiro parâmetro e a "proporção" como o segundo.
A proporção está entre 0 e 5, com 2 casas decimais.

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

Como você pode ver, não é o ideal.
O número 2 {echo}pode ser reduzido para 1.
Devido a um erro no compilador, esse código não pode ser reduzido muito mais.


Ungolfed:

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

Se nenhum erro existisse, o código ficaria assim: 86 bytes:

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

2

C # interativo, 77 67 bytes

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

C # interativo é legal.


11
Se você estiver usando o C # Interactive que precisa estar no cabeçalho, caso contrário, em C #, inclua using System;ou se qualifique totalmente Math. Além disso, não tenho certeza se você pode fazê-lo de forma interativa, mas você pode compilar um Func<string, Func<int, string>>para salvar bytes, ou seja,s=>p=>s+new...
TheLethalCoder

11
Além disso, você provavelmente não precisa a chamada para Math.Roundapenas lançando a um intdeve chamar Flooreo OP disse quer Floorou Ceilingé bom
TheLethalCoder

1

SmileBASIC, 29 bytes

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

como 3*4.99= 14.97, apenas 14ou 15seria aceitável como resposta, a versão de 29 bytes deve funcionar bem, desculpe!
colsw

1

Gol> <> (Golfe), 17 bytes

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

Experimente aqui .

A linha superior lê caracteres ( i) até encontrar uma nova linha (ASCII 10, a) e depois desce ( v).

Então descartamos um caractere (a nova linha) com ~, pressionamos o comprimento da pilha ( l), lemos um float ( I), multiplicamos os dois e repetidamente ( R) pressionamos o caractere ")" várias vezes. Finalmente, inverta a pilha ( r), faça a saída e pare ( H).


1

PHP, 50 bytes

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

toma string e número decimal como argumentos de linha de comando; corta o estofamento. Corra com -r;

demolir

<?=                     // 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

Ruby, 25 bytes

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

Estou usando lambdas . O programa de teste seria algo como:

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

1

Clojure, 68 bytes

Uma função anônima que aceita entrada decimal.

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

Literalmente, o primeiro programa Lisp que eu já escrevi! Eu já estou me divertindo.


Bem-vindo ao mundo do Lisp! : P No Clojure, você pode usar a forma condensada de funções anônimas #(...)e se livrar delas print(já que o retorno da função deve ser aceitável). Você pode mudar reducepara applypara a strfunção e pode mudar ")"para \), o que faz a mesma coisa. Assim, o código final deve ser: #(str %(apply str(repeat(*(count %)%2)\))))).
Clismique 5/05

Além disso, o estado atual do seu código não funciona; você (#(...) "codegolf" 125)deve adicionar 125 % do comprimento do "codegolf" em vez de 125 vezes o comprimento do "codegolf". Portanto, o programa fixo seria:, #(str %(apply str(repeat(*(count %)%2 1/100)\))))que é de 49 bytes.
Clismique 5/05

1

C ++ 14, 43 bytes

Como lambda sem nome, modificando sua entrada, assumindo que sé semelhante a std::string(has .append(int,char)e assumindo pser do tipo de ponto flutuante:

[](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;
}

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.