Dołączanie długości ciągów

51

Wyzwanie:

Biorąc pod uwagę ciąg sznaków a- z, A- Z, 0- 9, dołącz długość sdo siebie, licząc dodatkowe znaki w długości jako część całkowitej długości s.

Wejście:

Tylko ciąg o dowolnej długości (może być pusty).

Wynik:

Ten sam ciąg znaków, ale z długością dołączoną do końca. Znaki reprezentujące długość należy również liczyć jako część długości. W przypadkach, gdy istnieje wiele prawidłowych długości do dołączenia, wybierz najmniejszą możliwą (patrz przykłady przypadków testowych).

Przypadki testowe:

INPUT     -> OUTPUT       // Comment
aaa       -> aaa4
          -> 1            // Empty string
aaaaaaaa  -> aaaaaaaa9    // aaaaaaaa10 would also normally be valid, but violates using the smallest number rule mentioned above
aaaaaaaaa -> aaaaaaaaa11
a1        -> a13          // Input can contain numbers at the end of the string, you do not have to handle the fact that it looks like 13 rather than 3.

Longer test case(s):

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa -> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa101
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa -> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa102

Zasady:

To jest , więc wygrywa najkrótszy kod w bajtach. Standardowe luki są zabronione. Zgłoszenia mogą być całym programem lub funkcją i możesz albo wydrukować wynik na standardowe wyjście, albo zwrócić go jako zmienną z funkcji.

Jodła
źródło
Jakie znaki mogą pojawić się na wejściu?
Martin Ender,
@MartinEnder Tylko znaki alfanumeryczne, 0–9 i AZ / az. Więc tak, możesz mieć ciągi znaków z liczbami na końcu. Dodam przypadek testowy dla jednego.
Yodle

Odpowiedzi:

18

JavaScript (ES6), 32 bajty

f=(s,n=0)=>(s+n)[n]?f(s,n+1):s+n

Jak to działa

f = (s, n = 0) =>   // given a string 's' and starting with n = 0:
  (s + n)[n] ?      // if the Nth character of (s + n) exists:
    f(s, n + 1)     //   try again with n + 1
  :                 // else
    s + n           //   return s + n

Zaczynając od N=0, testujemy N-ty znak (oparty na 0) ciągu utworzonego z połączenia pierwotnego ciągu wejściowego i reprezentacji dziesiętnej N. Zwiększamy, Ndopóki ta postać już nie istnieje.

Przykład:

N =  0 : abcdefghi0
         ^
N =  1 : abcdefghi1
          ^
N =  2 : abcdefghi2
           ^
...
N =  8 : abcdefghi8
                 ^
N =  9 : abcdefghi9
                  ^
N = 10 : abcdefghi10
                   ^
N = 11 : abcdefghi11    -> success
                    ^

Przypadki testowe

Arnauld
źródło
Wow, JS jest do tego znacznie bardziej zaawansowany niż Python.
mbomb007
@Arnauld Nie mogę się tym zająć. Czy możesz wyjaśnić, jak działa ten kod?
Gowtham,
12

LaTeX, 108/171

\newcounter{c}\def\s#1#2]{\stepcounter{c}\def\t{#2}\ifx\empty\t\arabic{c}\else#1\s#2]\fi}\def\q[#1]{\s#10]}

\q[] //1

C5H8NNaO4
źródło
Whoa, nie sądzę, żebym kiedykolwiek widział lateksową odpowiedź na ppcg.
pajonk
5

JavaScript (ES6), 37 bajtów

f=(s,t=s,u=s+t.length)=>t==u?t:f(s,u)
<input oninput=o.textContent=f(this.value)><pre id=o>

Neil
źródło
Po kliknięciu pojawia Run Code Snippetsię komunikat o błędzie. Nie mam pojęcia o JavaScript - właśnie próbowałem
Prasanna,
@Prasanna Działa dla mnie w przeglądarce Firefox; jakiej przeglądarki używasz?
Neil,
@Prasanna Działa na najnowszej przeglądarce Google Chrome. Czy na pewno nie używasz IE11 lub starszej wersji, Opery lub czegokolwiek, co nie obsługuje ES6?
Ismael Miguel
Używam starego, dobrego chrome ( Version 48.0.2564.97). Spróbuję tego też z IE. Nie mogę zaktualizować mojego chromowanego - problemy z bezpieczeństwem pakietu Office
Prasanna,
5

C, 67 65 61 bajtów

x;f(*v){printf("%d",(int)log10(x=-~printf(v))*-~(x%10>8)+x);}

Wandbox

o79y
źródło
1
Och, tak, powinienem wydrukować ... W każdym razie gratuluję posiadania krótszego rozwiązania C: D +1
kot
4

Lua 5.2, 32 bajty

a=arg[1]print(a..#a+#(''..#a+1))

Gdzie zmienna a jest łańcuchem wejściowym.

żywica
źródło
3

Pyke, 8 bajtów ( stara wersja )

.f+liq)+

Wyjaśnienie:

.f    )  -  first where (i++)
  +      -    input + i
   l     -    len(^)
    iq   -   ^ == i
       + - input + ^

Wypróbuj tutaj! (Nowa wersja, 9 bajtów)

niebieski
źródło
Zawsze myli mnie, jak zakopana jest rzeczywista wydajność wśród ostrzeżeń lub innych wiadomości :-)
Luis Mendo
2
Naprawdę powinienem zająć się naprawą błędu internetowego w linku do kopiowania, który automatycznie wyłącza przełącznik ostrzeżeń
Blue
3

Python 2, 54 48 46 bajtów

Proste rozwiązanie. Rekurencja okazała się krótsza.

f=lambda s,n=0:f(s,n+1)if(s+`n`)[n:]else s+`n`

Wypróbuj online

mbomb007
źródło
1
Myślę, że można to zrobić (s+`n`)[n:]za n<len(s+`n`).
xnor
3

Haskell, 46 bajtów

f s=[l|i<-[0..],l<-[s++show i],length l==i]!!0

Przykład użycia: f "aaaaaaaa"-> "aaaaaaaa9".

Po prostu wypróbuj wszystkie liczby zaczynające się od 0 i wybierz pierwszą, która pasuje.

nimi
źródło
3

Mathematica, 57 bajtów

#<>ToString[(a=Length@#)+(i=IntegerLength)[a+i@a]~Max~1]&

Funkcja bez nazwy, która przyjmuje tablicę znaków jako dane wejściowe i zwraca ciąg znaków. Wykorzystuje fakt, że jeśli ajest długością wejściową, to liczba do dołączenia do niej jest apowiększona o liczbę cyfr w ( a+ długość a), a nie tylko o adodatkową liczbę cyfr a. Niestety nie dałby właściwej odpowiedzi dla danych wejściowych z pustym ciągiem bez ~Max~1specjalnego przypadku.

Greg Martin
źródło
3

Brachylog , 13 bajtów

l<L$@:?rc.lL,

Wypróbuj online!

Wyjaśnienie

Zasadniczo opis problemu. Spróbuje każdej wartości Lwiększej niż długość danych wejściowych, aż znajdzie tę, dla której po połączeniu z danymi wejściowymi jest długość tej konkatenacji.

l<L              length(Input) < L
  L$@            Convert L to a string
     :?rc.       The Output is the concatenation of the Input with L as string
         .lL,    The length of the Output is L itself
Fatalizować
źródło
3

Brainfuck, 258 bajtów

,>+<----------[++++++++++>+[>+<-],----------]<[<]>[.>]>>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]

Wejście musi być zakończone sygnałem liniowym (LF). Działa tylko w przypadku danych wejściowych o długości mniejszej niż 256 (w tym LF).

Wypróbuj online!

Wyjaśnienie

# read first char and add one to cell #1
# the cell after the input will contain the length
,>+<
# subtract 10 to check for LF
----------
# while the input is not 10 (LF)
[
# restore the input to its original value
++++++++++
# add one to the length
>+
# cut and paste the length to the next cell, then read the input
[>+<-],
# subtract 10 to check for LF
----------
]
# for input abc, the tape here would be: a b c *0* 4
# rewind to the beginning of the input
<[<]>
# print the input string
[.>]>
# convert the length to ascii chars and output them
>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-
<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++
<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]

Uwaga: Użyłem kodu z tej odpowiedzi SO do konwersji długości na wyjście ascii; Mam nadzieję, że jest to dopuszczalne na PPCG. To moje pierwsze zgłoszenie do Codegolfa i mój drugi program BF. Informacje zwrotne są mile widziane.

Forcent Vintier
źródło
1
To nie jest poprawne, musi przejść wszystkie przypadki testowe
cat
Czy wystarczyłoby wsparcie dla długości do 999?
Forcent Vintier
Specyfikacja mówi „dowolna długość”, co oznacza „tak długo, jak długo twój język jest w stanie obsłużyć pamięć lub nie zabraknie jej w pamięci”
cat
Używany przez ciebie interpreter mózgów ma 8-bitowe komórki, więc dopóki twój algorytm działa na łańcuchy o dowolnej długości, powinno być dobrze, jeśli zawiedzie dla łańcuchów o długości 256 lub wyższej. Przesyłanie C i JavaScript również nie powiedzie się, gdy łańcuchy będą zbyt długie.
Dennis
Dziękuję, Dennis, odpowiednio zmodyfikuję swoje zgłoszenie
Forcent Vintier,
2

Siatkówka , 22 bajty

\G`
.
x
+r`\d*$
$._
x

Wypróbuj online!

No cóż, gdyby nie cyfry pojawiające się na wejściu, byłoby to zaledwie 11 bajtów:

+r`\d*$
$._
Martin Ender
źródło
2

Rubin, 62 58 56 bajtów

s=gets.chomp;p s+"#{(s+"#{(s+"#{s.size}").size}").size}"

Testowane w irb.

Jest prawdopodobnie lepszy sposób, aby to zrobić, ale to była pierwsza rzecz, jaką wymyśliłem. Każda pomoc w grze w golfa będzie mile widziana.

edycja: Zdałem sobie sprawę, że moje użycie nawiasów było nadmierne.

Eleński
źródło
Używasz tylko lw jednym miejscu. Jeśli wstawisz to, zaoszczędzisz 3 bajty l=;. Ale twoje rozwiązanie będzie jeszcze dłuższe niż moje;)
DepressedDaniel
2

Perl 6 ,  46  35 bajtów

{$_~(.chars,*.chars+.chars...{$^a==$^b})[*-1]}
{$_~(.chars,*.chars+.chars...*)[2]}

Spróbuj

Rozszerzony:

{   # bare block lambda with implicit parameter 「$_」

  $_  # the input

  ~   # concatenated with

  (  # sequence generator

    .chars,  # the number of chars in 「$_」 (seed the generator)


    *\      # Whatever lambda input (represents previous value)
    .chars  # number of chars in that
    +       # plus
    .chars  # the number of chars in 「$_」


    ...     # keep doing that until

    *       # indefinitely

  )[2] # get the value at index 2 of the sequence
}
Brad Gilbert b2gills
źródło
2

05AB1E , 11 bajtów

[¹¾JDg¾Q#¼\

Dość prosta brutalność:

            Implicit i = 0
[           while true
 ¹¾J        Concatenate input and i -> str
    Dg¾Q#   Break if length(str) == i
         ¼\ Else, i += 1

Wypróbuj online!

Osable
źródło
2

Python, 39 bajtów

lambda a:eval('a+str(len('*3+'a))))))')

Dłuższa forma:

lambda a:a+str(len(a+str(len(a+str(len(a))))))

Iteracyjnie w Pythonie 2 (41 bajtów):

x=a=input();exec"x=a+`len(x)`;"*3;print x

Zaczynając xjako ciąg wejściowy a, stosuje transformację x -> a + str(len(x))trzy razy. Nadal nie jestem pewien, dlaczego trzy aplikacje są potrzebne, aby zawsze osiągnąć stały punkt.

xnor
źródło
Dlaczego 3 razy? Najpierw dodaj długość tekstu, po drugie dostosuj długość tak, aby zawierała liczbę, po trzecie, w przypadku, gdy dostosowanie dodało dodatkową cyfrę.
Tom Viner,
2

PHP, 42 bajty

while(++$n<strlen($a=$argv[1].$n));echo$a;

Uruchom z -r. Testuj w trybie OnlinePHP .

Tytus
źródło
2

bash, 47 bajtów

 for((n=-1;${#s} != $n;));{ s=$1$[++n];};echo $s

Zapisz to jako skrypt i przekaż ciąg wejściowy jako argument.

To implementacja brutalnej siły: wypróbuj kolejno każdy numer, aż znajdziesz taki, który działa.

Mitchell Spector
źródło
2

> <> (Ryba) 35 bajtów

i:1+?!v:o
ln;v9l<  >
*9+>:&)?!^1l&a

Pobiera dane wejściowe na stos, sprawdza długość względem wartości 9 999 999 ... i jeśli długość jest większa niż dodać 1 do długości stosu.

Pelikan turkusowy
źródło
2

Haskell , 61 60 bajtów

e=length
l%n|s<-show$l+1,n>e s=s|m<-n+1=(l+1)%m
c s=s++e s%2

Wypróbuj online!

Rozwiązanie rekurencyjne. Stosowanie:

Prelude> c "aaaaaaaaa"
"aaaaaaaaa11"
Laikoni
źródło
1

C #, 77 bajtów

n=>{int a=n.Length;int c=(a+1).ToString().Length-1;return(n+(n.Length+1+c));}
Alfie Goodacre
źródło
1
Nie mam teraz C #, ale nie możesz użyć return(n+(a+1+c))jako a=n.Length?
Laikoni
A także upuść -1z int c=(a+1).ToString().Length-1a +1z powrotem?
Laikoni
1
Zaraz, czy to poprawnie obsługuje większe przypadki testowe? Wygląda na to, że zwraca aa...a100zamiast aa...a101dla aprzypadku testowego 99 .
Laikoni
1

MATL , 11 bajtów

`G@Vhtn@>]&

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

`      % Do...while
  G    %   Push input
  @    %   Push iteration index (1-based)
  V    %   Convert number to string
  h    %   Concatenate horizontally
  t    %   Duplicate
  n    %   Get length of concatenated string
  @    %   Push iteration index
  >    %   True if length of concatenated string exceeds iteration index
]      % End. Run next iteration if top of stack is true; else exit loop
&      % Specifiy that next function (implicit display) takes only one input
       % Implicitly display top of the stack. This is the concatenated string
       % that had a length equal to the iteration index
Luis Mendo
źródło
1

Ruby, 51 bajtów (program)

Ruby, 49 bajtów (funkcja)

Program (ostatni znak nowej linii nie jest konieczny i dlatego nie jest oceniany):

x=gets.strip
i=0
i+=1 until(y=x+i.to_s).size==i
p y

Funkcja (ostatnia nowa linia jest punktowana):

def f x
i=0
i+=1 until(y=x+i.to_s).size==i
y
end
DepressedDaniel
źródło
1

Współczynnik, 55 bajtów

To spacer w parku! Wymyśliłem to w mojej głowie, gdy tylko przeczytałem pytanie.

[ dup length dup log10 ⌈ + >integer 10 >base append ]
kot
źródło
1

Clojure, 72 bajty

(defn f([s](f s 1))([s n](if(=(count(str s n))n)(str s n)(f s(inc n)))))
NikoNyrh
źródło
1

R, 49 bajtów

cat(a<-scan(,""),(t<-nchar(a))+nchar(t+1),sep='')

Całkiem proste rozwiązanie.

Frédéric
źródło
To nie działa na mnie Read 1 item Error in nchar(x + 1) : object 'x' not found. Znalazłem, że (t<-nchar(a))+...zadziałało.
JAD
@JarkoDubbeldam: My bad!
Frédéric,
1

Wolfram, 56

#<>ToString@Nest[l+IntegerLength@#&,l=StringLength@#,2]&

Biorąc pod uwagę, l = StringLength[x]że dołącza się l + IntegerLength[l + IntegerLength[l]]do x.

śmigać
źródło
1

ForceLang, 83 bajty

set s io.readln()
label 1
set n 1+n
set t s+n
if t.len=n
 io.write t
 exit()
goto 1
SuperJedi224
źródło