Anhängen von Zeichenfolgenlängen

51

Herausforderung:

Wenn Sie eine Zeichenfolge sfür die Zeichen a- z, A- Z, 0- 9angeben, hängen Sie die Länge von san sich selbst an und zählen die zusätzlichen Zeichen in der Länge als Teil der Gesamtlänge von s.

Eingang:

Nur eine Zeichenfolge von beliebiger Länge (kann leer sein).

Ausgabe:

Dieselbe Zeichenfolge, aber mit der Länge am Ende angehängt. Die Zeichen, die die Länge darstellen, sollten ebenfalls als Teil der Länge gezählt werden. In Fällen, in denen mehrere gültige Längen angehängt werden müssen, wählen Sie die kleinstmögliche aus (Beispiele finden Sie unter Testfälle).

Testfälle:

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

Regeln:

Das ist , also gewinnt der kürzeste Code in Bytes. Standardlücken sind verboten. Einsendungen können ein gesamtes Programm oder eine Funktion sein, und Sie können entweder das Ergebnis als Standardausgabe drucken oder es als Variable von einer Funktion zurückgeben.

Jodler
quelle
Welche Zeichen können in der Eingabe erscheinen?
Martin Ender
@MartinEnder Nur alphanumerische Zeichen, 0-9 und AZ / az. Also ja, Sie können Zeichenfolgen mit Zahlen am Ende haben. Ich werde einen Testfall für einen hinzufügen.
Jodler

Antworten:

18

JavaScript (ES6), 32 Byte

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

Wie es funktioniert

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

Beginnend mit N=0testen wir das N-te Zeichen (0-basiert) der Zeichenfolge, die aus der Verkettung der ursprünglichen Eingabezeichenfolge und der Dezimaldarstellung von besteht N. Wir erhöhen, Nbis dieses Zeichen nicht mehr existiert.

Beispiel:

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

Testfälle

Arnauld
quelle
Wow, JS ist dafür viel knapper als Python.
mbomb007
@Arnauld Ich kann das nicht verstehen. Haben Sie etwas dagegen zu erklären, wie dieser Code funktioniert?
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
quelle
Ich glaube, ich habe noch nie eine Latexantwort auf PPCG gesehen.
Pajonk
5

JavaScript (ES6), 37 Byte

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
quelle
Beim Klicken auf wird Run Code Snippeteine Fehlermeldung angezeigt. Ich habe keine Javascript-Kenntnisse - ich habe es nur versucht
Prasanna
@Prasanna Funktioniert für mich in Firefox; Welchen Browser verwenden Sie?
Neil
@Prasanna Funktioniert mit dem neuesten Google Chrome. Sind Sie sicher, dass Sie nicht IE11 oder älter, Opera oder etwas anderes verwenden, das ES6 nicht unterstützt?
Ismael Miguel
Ich benutze ein altes gutes Chrom ( Version 48.0.2564.97). Ich werde dies auch mit IE versuchen. Mein Chrome kann nicht aktualisiert werden - Office-Sicherheitsprobleme
Prasanna
5

C 67 65 61 Bytes

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

Wandbox

o79y
quelle
1
Ohh, ja, ich hätte drucken sollen ... Wie auch immer, herzlichen Glückwunsch zu der kürzeren C-Lösung: D +1
Katze
4

Lua 5.2, 32 Bytes

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

Wobei die Variable a die Eingabezeichenfolge ist.

Harz
quelle
3

Pyke, 8 Bytes ( alte Version )

.f+liq)+

Erläuterung:

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

Probieren Sie es hier aus! (Neue Version, 9 Bytes)

Blau
quelle
Es verwirrt mich immer, wie vergraben die tatsächliche Ausgabe unter Warnungen oder anderen Meldungen ist :-)
Luis Mendo
2
Ich sollte mich wirklich darum kümmern, den Web-Fehler im Kopierlink zu beheben, der den Warnungsschalter automatisch deaktiviert
Blue
3

Python 2, 54 48 46 Bytes

Einfache lösung. Die Rekursion war kürzer.

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

Probieren Sie es online aus

mbomb007
quelle
1
Ich glaube , Sie können tun (s+`n`)[n:]für n<len(s+`n`).
16.
3

Haskell, 46 Bytes

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

Anwendungsbeispiel: f "aaaaaaaa"-> "aaaaaaaa9".

Probieren Sie einfach alle Zahlen aus, die mit 0 beginnen und nehmen Sie die erste, die passt.

nimi
quelle
3

Mathematica, 57 Bytes

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

Unbenannte Funktion, die ein Array von Zeichen als Eingabe verwendet und eine Zeichenfolge zurückgibt. Verwendet die Tatsache, dass, wenn adie Länge der Eingabe ist, die an die Eingabe anzuhängende Zahl aplus die Anzahl der Stellen in ( a+ die Länge von a) ist und nicht nur aplus die Anzahl der Stellen von a. Leider würde es ohne den ~Max~1Sonderfall nicht die richtige Antwort für die Leerstring-Eingabe geben .

Greg Martin
quelle
3

Brachylog , 13 Bytes

l<L$@:?rc.lL,

Probieren Sie es online!

Erläuterung

Grundsätzlich eine Beschreibung des Problems. Jeder Wert, der Lgrößer als die Länge der Eingabe ist, wird geprüft, bis ein Wert gefunden wird , dessen Verkettung mit der Eingabe die Länge dieser Verkettung ist.

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
Tödlich
quelle
3

Brainfuck, 258 Bytes

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

Die Eingabe muss durch einen Zeilenvorschub (LF) abgeschlossen werden. Funktioniert nur für Eingaben mit einer Länge von weniger als 256 (einschließlich LF).

Probieren Sie es online!

Erläuterung

# 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
>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-
<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++
<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]

Hinweis: Ich habe Code aus dieser SO-Antwort verwendet , um die Länge in ASCII-Ausgabe zu konvertieren. Ich hoffe, dass dies bei PPCG akzeptabel ist. Dies ist meine erste Codegolf-Einsendung und mein zweites BF-Programm. Feedback ist willkommen.

Forcent Vintier
quelle
1
Dies ist dann nicht gültig, es muss alle Testfälle bestehen
Katze
Eine Länge bis zu 999 wäre also ausreichend?
Forcent Vintier
Die Spezifikation sagt "willkürliche Länge", was bedeutet, "solange Ihre Sprache in der Lage ist, mit Speicher fertig zu werden oder nicht"
cat
Der von Ihnen verwendete Brainfuck-Interpreter verfügt über 8-Bit-Zellen. Solange Ihr Algorithmus für Zeichenfolgen beliebiger Länge funktioniert, sollte er in Ordnung sein, wenn er für Zeichenfolgen mit einer Länge von 256 oder mehr fehlschlägt . Die C- und JavaScript-Übermittlungen schlagen auch fehl, wenn die Zeichenfolgen zu lang werden.
Dennis
Vielen Dank, Dennis, ich werde meine Einsendung entsprechend ändern
Forcent Vintier
2

Ruby, 62 58 56 Bytes

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

Getestet in irb.

Es gibt wahrscheinlich einen besseren Weg, dies zu tun, aber das war das erste, was ich mir ausgedacht habe. Jede Hilfe beim Golfen wäre dankbar.

edit: Mir ist aufgefallen, dass ich zu viele Klammern verwendet habe.

Elenian
quelle
Sie verwenden nur lan einem Ort. Wenn Sie das einbinden, sparen Sie 3 Bytes l=;. Aber deine Lösung wird immer noch länger sein als meine;)
DepressedDaniel
2

Perl 6 ,  46  35 Bytes

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

Versuch es

Erweitert:

{   # 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
quelle
2

05AB1E , 11 Bytes

[¹¾JDg¾Q#¼\

Ziemlich unkomplizierte Bruteforce:

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

Probieren Sie es online!

Osable
quelle
2

Python, 39 Bytes

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

Längere Form:

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

Iterativ in Python 2 (41 Byte):

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

Beginnend mit xals Eingabezeichenfolge awird die Transformation x -> a + str(len(x))dreimal angewendet. Mir ist immer noch nicht klar, warum drei Anwendungen benötigt werden, um immer den Fixpunkt zu erreichen.

xnor
quelle
Warum 3 mal? Erstens, um die Textlänge anzuhängen, zweitens, um die Länge so anzupassen, dass sie die Zahl enthält, und drittens, falls durch die Anpassung eine zusätzliche Ziffer hinzugefügt wurde.
Tom Viner
2

PHP, 42 Bytes

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

Laufen Sie mit -r. Test bei OnlinePHPfunctions .

Titus
quelle
2

Bash, 47 Bytes

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

Speichern Sie dies als Skript und übergeben Sie die Eingabezeichenfolge als Argument.

Es ist eine Brute-Force-Implementierung: Probieren Sie jede Zahl der Reihe nach aus, bis Sie eine finden, die funktioniert.

Mitchell Spector
quelle
2

> <> (Fisch) 35 Bytes

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

Nimmt Eingaben in den Stapel auf, vergleicht die Länge mit den Werten 9,99,999 ... und addiert 1 zur Stapellänge, wenn die Länge größer ist.

Blaugrüner Pelikan
quelle
2

Haskell , 61-60 Bytes

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

Probieren Sie es online!

Rekursive Lösung. Verwendungszweck:

Prelude> c "aaaaaaaaa"
"aaaaaaaaa11"
Laikoni
quelle
1

C #, 77 Bytes

n=>{int a=n.Length;int c=(a+1).ToString().Length-1;return(n+(n.Length+1+c));}
Alfie Goodacre
quelle
1
Ich weiß nicht jetzt C #, aber können Sie nicht return(n+(a+1+c))als verwenden a=n.Length?
Laikoni
Und auch die -1von int c=(a+1).ToString().Length-1und +1von der Rückgabe fallen lassen?
Laikoni
1
Warten Sie, behandelt dies die größeren Testfälle korrekt? Es sieht aus wie es gibt aa...a100statt aa...a101für den 99 aTestfall.
Laikoni
1

MATL , 11 Bytes

`G@Vhtn@>]&

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

`      % 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
quelle
1

Ruby, 51 Bytes (Programm)

Ruby, 49 Bytes (Funktion)

Programm (letzter Zeilenumbruch ist nicht erforderlich und daher nicht bewertet):

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

Funktion (letzte Zeile wird gewertet):

def f x
i=0
i+=1 until(y=x+i.to_s).size==i
y
end
DepressedDaniel
quelle
1

Faktor 55 Bytes

Es ist ein Spaziergang im Park! Sobald ich die Frage gelesen hatte, fiel mir dies in meinem Kopf ein.

[ dup length dup log10 ⌈ + >integer 10 >base append ]
Katze
quelle
1

Clojure, 72 Bytes

(defn f([s](f s 1))([s n](if(=(count(str s n))n)(str s n)(f s(inc n)))))
NikoNyrh
quelle
1

R, 49 Bytes

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

Ziemlich einfache Lösung.

Frédéric
quelle
Dies gilt nicht für mich arbeiten: Read 1 item Error in nchar(x + 1) : object 'x' not found. Ich fand, dass (t<-nchar(a))+...das funktioniert hat.
JAD
@ JarkoDubbeldam: Mein schlechtes!
Frédéric
1

Wolfram, 56

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

Da l = StringLength[x]hängt es l + IntegerLength[l + IntegerLength[l]]an x.

Swish
quelle
1

ForceLang, 83 Bytes

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
quelle