Giriş

Aşağıdaki dizgeyi izleyelim:

ABCDEFGHIJKLMNOP

Dizenin uçlarını değiştirirsek, bunlar:

ABCDEFGHIJKLMNOP
^^            ^^

Aşağıdaki sonucu alıyoruz:

BACDEFGHIJKLMNPO

Bundan sonra, bu durumda olan Bve dizgenin uçlarını sileriz O. Sonuç:

ACDEFGHIJKLMNP

İşlemi tekrarlarsak aşağıdaki listeye ulaşırız:

N     Result

2     ADEFGHIJKLMP
3     AEFGHIJKLP
4     AFGHIJKP
5     AGHIJP
6     AHIP
7     AP

Aşağıdakiler için olduğunu görebilirsiniz N = 5 , sonucudur AGHIJP. At N = 7 , dize uzunluğu daha küçüktür 3 N böylece> 7 olarak kabul edilir, geçersiz bu durumda.

Görev

Bir dizge verilen S ile en az 4 uzunluğunda ve tekrar sayısı K > 0 ise, çıkış Sonuç. N'nin her zaman geçerli olduğunu varsayabilirsin .

Test durumları

Input                               >  Output

N = 3, S = ABCDEFGHIJKLMNOP         >  AEFGHIJKLP
N = 1, S = Hello                    >  Hlo
N = 2, S = 123321                   >  11

Bu kod-golf , bu yüzden en az sayıda bayt olan gönderim kazanıyor! Basit olması için, dizenin yalnızca alfasayısal karakterler içereceğini varsayabilirsiniz .

MATL , 8 9 12 13 bayt

th"P[]2(

Girdiler: ilk önce Ntırnak işaretli tek bir dize olarak (itiraz tarafından izin verilir); İkincisi Stırnaklı bir dize olarak (dize içindeki tırnaklara varsayılan olarak izin verilir); bir satır sonu ile ayrılmış.

Bu, ipi çevirerek, ikinci elemanını sökerek ve toplam 2*Nkez tekrarlayarak çalışır .

Çevrimiçi deneyin!

th       % implicitly take first input (N) as a unary string. Concatenate horizontally
         % with itself: gives a string of 2*N ones
"        % for each (i.e., repeat 2*N times)
  P      %   flip string. Take S implicitly as input the first time
  []     %   empty array (used as new contents)
  2      %   2 (used as index)
  (      %   assign [] to position 2 of string; that is, remove second element
         % implicitly end for each
         % implicitly display

Retina , 44 20 bayt

_{44'ü geçip hala 44}

+`'(\w).(.*).\B
$1$2

Girdiyi aşağıdaki formatta kabul eder (tek sayı - karakter sayılır:) ':
{number of repeats}{string}
Örneğin: '''''''ABCDEFGHIJKLMNOP
Tekrar sayısı ve dizi arasında boşluk yoktur.

24 byte'ı tıraş ettiğiniz için teşekkürler @ MartinBüttner !

Çevrimiçi deneyin!

Python 2,31 bayt

lambda s,n:s[0]+s[n+1:~n]+s[-1]

Bence bu işe yarıyor mu?

Mathematica, 29 bayt

İlk cevabım!

#~Delete~{{2},{-2}}&~Nest~##&

Parantezsiz Mathematica'nın zekası! İşlev girişleri bir liste (karakter veya her neyse) ve bir sayıdır.

Labirent , 40 bayt

<
,,}:?
.
;("   {(={}{".
,",;=};} }) "{@

Girdiyi, Nsayısal olmayan herhangi bir karakterle ayrılmış dizge izler.

Çevrimiçi deneyin!

Bu Sp3000 ile birlikte yazılmıştır (yani bir algoritma bulmak için canımı sıkmazdım, bu yüzden üzerinde çalışmaya başladı, 118 baytlık bir çözüm üretti, ancak golfü rahatsız edemedi, bu yüzden golf oynadım.) .. takım çalışması için yay).

açıklama

Sp'in normal astarı (her zamanki gibi hafifçe değiştirilmiş):

• Labirent, ana ve yardımcı olmak üzere iki yığıntan oluşan yığın tabanlı bir 2B dilidir. Ana yığında hemen hemen her şey olur, ancak değerleri diğerine kaydırabilirsiniz, örneğin bunları tersine çevirmek veya daha sonra kullanmak üzere saklayabilirsiniz.
• Yığınlar dipsizdir ve sıfırlarla doludur, bu nedenle boş bir yığıntan çıkmak bir hata değildir.
• Yürütme ilk geçerli karakterden başlar (burada sol üstte). Her bir kavşakta, talimat göstergesinin (IP) alınması için iki veya daha fazla yolun olduğu yerlerde, nereye gidileceğini belirlemek için yığının tepesi kontrol edilir. Negatif sola döner, sıfır ileri gider ve pozitif sağa döner. Bu edilirken geliyordu , kıvrılan pasajlar sarma gibi kod görünmesi için, bu koşullar her hücrede kontrol edilir "odalar" yapmaktan durdurma şey yok. Bunlar tahmin edilemez davranışlar sağlayabilir, ancak golf oynamak için mükemmeldir.
• Kaynak kod (ve bu nedenle labirentin yerleşimi), çalışma <>^vsırasındaki bir satır veya sütunu veya ızgarayı döngüsel olarak değiştiren çalışma zamanında değiştirilebilir .
• " hayır ops.

İşte başlıyoruz.

Kod <, uzun bir lineer kod parçası ile başlarken birkaç kez kullandığım bir golf oyunudur. İlk satırı döngüsel olarak sola kaydırır, IP üzerindedir , böylece kaynak şöyle görünür:

              <
,,}:?
.
;("   {(={}{".
,",;=};} }) "{@

Fakat şimdi IP hiçbir yere taşınamıyor, bu yüzden <tekrar yürütüyor . Bu, bu duruma ulaşana kadar devam eder:

    <
,,}:?
.
;("   {(={}{".
,",;=};} }) "{@

Bu noktada IP, hücreden ayrılabilir ve ?. Öyleyse işte doğrusal kod bozuldu:

?   # Read the first integer on STDIN, i.e. N.
:}  # Duplicate it and move one copy over to the auxiliary stack.
,   # Read the separator character.
,.  # Read the first character of the input string and directly print it.

IP şimdi 2x2 saat yönünde iki adet sıkıca sıkıştırılmış (örtüşen) 2x2 döngü olan bu 3x2 odasına giriyor. İlk döngü N-1karakterleri STDIN'den okur ve atar .

;   # Discard the top of the stack. On the first iteration, this is the
    # separator we've already read. On subsequent iterations this will be
    # one of the N-1 characters from the input string.
(   # Decrement N. If this hits zero, we leave the loop, otherwise we continue.
,   # Read the next character from STDIN to be discarded.

Şimdi girdi dizisinin kalanını okuyan ikinci döngüye giriyoruz. Çünkü EOF algılayabilir ,dönecektir -1bu durumda IP sola yapım.

,   # Read a character. Exit the loop if EOF.
(   # Decrement it.

Bu düşüş aslında işe yaramaz, ancak daha sonra ücretsiz olarak geri alabiliriz ve burada iki döngüyü üst üste binmemize izin verir.

5 ABCDEFGHIJKLMNOPGirdiyi örnek olarak alırsak , yığın şöyle görünür:

Main [ ... 'E' 'F' 'G' 'H' 'I' 'J' 'K' 'L' 'M' 'N' 'O' -1  |  5 ... ] Auxiliary

Bunların aslında giriş karakterlerine karşılık geldiğini FGHIJKLMNOP(onları azalttığımız için) ve gerçekte bunlardan ilkini basmak istemediğimizi unutmayın (yalnızca N-1karakterleri attık , ancak atlamak istiyoruz N).

Şimdi yığını bir sonraki döngü için hazırlayan kısa bir doğrusal bit var:

;   # Discard the -1.
=   # Swap the tops of the stacks, i.e. N with the last character. 
    # By putting the last character on the auxiliary stack, we ensure that
    # it doesn't get discarded in the next loop.
}   # Move N over to the auxiliary stack as well.

Yığınlar şimdi şuna benziyor:

Main [ ... 'E' 'F' 'G' 'H' 'I' 'J' 'K' 'L' 'M' 'N'  |  5 'O' ... ] Auxiliary

Saat yönünde bir 2x2 daha giriyoruz. Bu N, ana karakterdeki üst karakterleri atar :

;   # Discard the top of the main stack.
{   # Pull N over from the auxiliary stack.
(   # Decrement it. It it's 0 we leave the loop.
}   # Push N back to the auxiliary stack.

=Dönüştüğümüzde döngü onu 0ve giriş dizesinin son karakterini tekrar değiştirir. Şimdi yığınlar şuna benziyor:

Main [ ... 'E' 'F' 'G' 'H' 'I' 'O'  |  ... ] Auxiliary

Ana yığının içeriğini (alt eleman hariç ve tümü 1 ile artırılmış olarak) soldan yazdırmak istiyoruz . Bu, yardımcı yığına geçmemiz gerektiği anlamına gelir. Sonraki 2x2 (saat yönünde) döngünün yaptığı şey:

{   # Pull an element over from the auxiliary stack. This is necessary so we
    # have a 0 on top of the stack when entering the loop, to prevent the IP
    # from turning right immediately.
}   # Move the top of the main stack back to the auxiliary stack. If this was the
    # bottom of the stack, exit the loop.
)   # Increment the current character.
}   # Move it over to the auxiliary stack.

Şimdi yığınlar:

Main [ ...  |  'F' 'G' 'H' 'I' 'J' 'P] ... ] Auxiliary

Bunlardan ilki (basmak istemediğimiz) ana yığına geri götürüyoruz {. Ve şimdi son 2x2 ( saat yönünün tersine ) döngüsüne giriyoruz , gerisini yazdırıyor:

{   # Pull another character over from the auxiliary stack. Exit the loop
    # if that's the zero at the bottom of the stack.
.   # Print the character.

Sonunda programı sonlandırıyoruz @.

JavaScript (ES6), 39 bayt

(s,n)=>s[0]+s.slice(++n,-n)+s.slice(-1)

Görünüşe göre Sp3000'in cevabını @ icat ettim.

Jöle, 8 bayt

Ḣ1¦UðḤ}¡

Çevrimiçi deneyin!

Nasıl çalışır

Ḣ1¦UðḤ}¡  Main link. Left input: S (string). Right input: N (deletions)

Ḣ         Pop the first element of S.
          This return the element and modifies S.
 1¦       Apply the result to the first index.
          This replaces the first character of the popped S with the popped char.
   U      Upend/reverse the resulting string.
    ð     Convert the preceding chain into a (dyadic) link.
     Ḥ}   Apply double to the right input.
          This yields 2N.
       ¡  Repeat the link 2N times.

Jöle , 10 bayt

Ḣ;ṪjḊṖ$Ɠ¡F

Giriş STDIN'den aracılığıyla numarası ve komut satırı args yoluyla dize . @Dennis'e bir sürü ipucu / bunun işe yarayabilmesi için teşekkürler (Jelly hala beni rahatsız ediyor).

Çevrimiçi deneyin!

Ḣ;Ṫ               Pop first and last chars of string and concatenate
   j              Join by...
       Ɠ¡           Execute n times...
    ḊṖ$               Drop first, drop last of string ($ combines the two monadically)
         F        Flatten to filter out empty lists, since Jelly's j is weird

Pyth, 13 bayt

++hz:zhQ_hQez

Açıklama:

              - autoassign z = input()
              - autoassign Q = eval(input())
    :zhQ_hQ   -  z[Q+1:-(Q+1)]
++hz       ez - z[0]+^+z[-1]

Burada dene

Vitsy, 12 9 (kod) + 1 (işlev bildirimi için yeni satır) = 10 bayt

\O/

Yığındaki girdiyi, ardından gelen sayıyı dizge olarak bekler.

2*\[vXvr]
2*         Multiply by 2.
  \[    ]  Do the stuff in the brackets that many times. (input num * 2)
    v      Take the top item off the stack and save it as a local variable.
     X     Remove the top item of the stack.
      v    Push the temporary variable back onto the stack.
       r   Reverse the stack.

Hangi ile arayabilirsin:

'String' r <number> 1m Z
2*\[vXvr]

Bu sonuç dizesini yığında bırakan bir fonksiyondur. TryItOnline bağlantısında bir program olarak verdim.

TryItOnline!

Python 2, 49 48 bayt

g=lambda s,n:n and g(s[0]+s[2:-2]+s[-1],n-1)or s

Testcases ile burada deneyin!

Basit özyinelemeli çözüm. Giriş dizesi ikinciye ve son saniyede öğesini kaldırır ve bununla ve kendisini çağıran n-1kadar n=0.

düzenleme: Kendini aptal hissetmek , diğer piton çözümlerine bakmak . Sanırım sadece özyinelemeyi çok seviyorum ...

C, 96 bayt

i;main(c,v,p)char**v,*p;{i=atoi(v[2])+1;c=strlen(p=v[1]);printf("%c%.*s%s",*p,c-2*i,p+i,p+c-1);}

Ungolfed

i; /* Param 2, the number of chars to remove */

main(c,v,p)char**v,*p;
{
    i=atoi(v[2])+1; /* convert param 2 to integer */
    c=strlen(p=v[1]); /* Length of the input */
    printf("%c%.*s%s",*p, /* Print the first char... */
        c-2*i, /* a number of characters equal to the length minus twice the input... */
        p+i, /* skip the "removed" chars... */
        p+c-1); /* Print the last character of the string */
}

Ruby, 29 bayt

->s,n{s[0]+s[n+1...~n]+s[-1]}

Çok basit.

~bir bayttan tasarruf sağlayan Sp'in cevabından çalınan hileler s[n+1..-2-n]. (Çünkü çalışır ~nolduğunu -1-ntwo's-tamamlayıcı ve sonra ...özel bir aralıktır.)

Perl, 36 32 + 1 = 33 bayt

for$i(1..<>){s;\B.(.+).(.);$1$2;}

-pBayrak gerektirir ve sonunda yinelenen sayılarla iki satırda girdi alır:

$ perl -pe'for$i(1..<>){s;\B.(.+).(.);$1$2;}' <<< $'ABCDEFGHIJKLMNOP\n4'
AFGHIJKP

Ungolfed?

for $i ( 1..<> ) {
  s;
  \B.(.+).(.);$1$2;x
}

CJam, 12 bayt

q~{VW@)t(t}*

Çevrimiçi deneyin!

Nasıl çalışır

q~            Read and evaluate all input. This pushes S (string) and N (integer).
  {       }*  Do the following N times:
   VW           Push 0 and -1.
     @          Rotate S on top of them.
      )         Pop the last character of S.
       t        Set the item at index -1 to that character.
        (       Pop the first character of S.
         t      Set the item at index 0 to that character.

Octave, 28 bayt

@(S,N)S([1,N+2:end-N-1,end])

Dizeyi dizine alın, atlayarak S(2:N+1) ve S(end-N:end-1).

İdeone üzerinde örnek çalışması .

Pas, 135 bayt

Bu oldukça korkunç bir uzunluk.

fn f(s:&str,n:usize)->String{let s=s.as_bytes();s[..1].iter().chain(&s[n+1..s.len()-n-1]).chain(s.last()).map(|d|*d as char).collect()}

Oldukça baskılı:

fn f(s: &str, n: usize) -> String {
    let s = s.as_bytes();
    s[..1].iter()
          .chain(&s[n+1..s.len()-n-1])
          .chain(s.last())
          .map(|d| *d as char)
          .collect()
}

Uygun dizeler yerine bytestrings işlevine izin verirsek onu 104 bayta indirebilirsin.

fn f(s:&[u8],n:usize)->Vec<u8>{let mut r=vec![s[0]];r.extend(&s[n+1..s.len()-n-1]);r.extend(s.last());r}

Oldukça baskılı:

fn f(s: &[u8], n: usize) -> Vec<u8> {
    let mut r = vec![s[0]];
    r.extend(&s[n+1..s.len()-n-1]);
    r.extend(s.last());
    r
 }

Biri daha iyisini yapabilirse merak ediyorum.

mSL - 137 bayt

c {
%l = $len($1)
return $mid($+($mid($1,2,1),$left($1,1),$right($left($1,-2),-2),$right($1,1),$mid($1,$calc(%l -1),1)),2,$calc(%l -2))
}

Açıklama:

%l = $len($1) Giriş dizesinin uzunluğunu alır ve onu l denilen değişkende saklar.

$right(<input>,<length>)ve $left(<input>,<length>orijinal dizginin sol veya sağ tarafını sırasıyla döndürmek için kullanılabilir. $ left, her zaman sol taraftan başlayarak metni döndürür, $ right her zaman sağdan başlayan metni döndürür. Belirtilen uzunluk negatif bir sayıysa, $ left ve $ right, metninin tamamını bu eksi karakterlerden kendi taraflarından döndürür.

$mid(<string>,<start>,[length])dize ortasından bir alt dize almak için kullanılır. Başlat alt dizenin soldan başlamasıdır. Negatif bir değer, sağdan başladığını gösterir. Her iki durumda da isteğe bağlı bir uzunluk belirtilebilir. Negatif bir uzunluk, bu kadar fazla karakteri sondan kaldırmak için kullanılabilir. Bu yüzden ikinci karakter ve ikinci son karakteri girdi dizgisinin uzunluğunu kullanarak almak için kullandım.

$calc(<input>) matematiksel hesaplamaları yapmak için kullanılır

Henüz başlıksız bir dil (yani yeni olmayan rekabetçi), 9 bayt

hD_RQ:Q|J

Kaynak kodunu burada bulabilirsiniz , dil tamamen dengesizdir (bunun için ilk sınav zorunluluğu vardır), bu yüzden gelecekte çalışmasını beklemeyin (7)

Bu, yığına nesne ekleyip kaldıran işlevlere sahip yığın tabanlı bir dildir. Şu anda 2 yığın manipülasyon komutu vardır: D(yığının N defa üstünü kopyala) ve R(yığındaki ilk N maddeyi döndür)

Açıklama:

          - autoassign Q = eval_or_not(input()) (string)
h         - imp_eval_input()+1
 D        - duplicate(^)
  _       - neg(^)
   R      - rotate(^)
    Q:    - Q[^:^]
      Q|  - Q[0], Q[-1]
        J - "".join(all)

CJam, 14 bayt

l(o)\l~_W*@<>o

Burada test et.

açıklama

l   e# Read the input string.
(o  e# Pull off the first character and print it.
)\  e# Pull off the last character and swap with the rest of the string.
l~  e# Read the second line of the input and evaluate it (N).
_   e# Duplicate.
W*  e# Multiply by -1 to get -N.
@   e# Pull up the string.
<   e# Discard the last N characters.
>   e# Discard the first N characters.
o   e# Output what's left. The last character of the input is now still on the
    e# stack and is automatically printed at the end of the program.

Vim, 27 bayt

o0lxehx <ESC>"ay0ddA@a<ESC>B"bdWx@b

Girişin, STRING Nilk satırda başka karakter içermeyen biçimde olması bekleniyor .

Açıklama:

#Write a macro to do one round of the swap and delete and save to register a
o0lxehx <ESC>"ay0dd

#Append register a to N and save in register B so it will run @a N times.
A@a<ESC>B"bdWx

# Actually run the macro
@b

Brainfuck, 130 bayt

İlk PPCG girişim!

Açıkçası kazanamayacaksın ama hey.

Gibi girdi alır: 4ABCDEFGHIJKL, ilk karakter N'dir.

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

Bunu test et harika sitede .

9 rakamdan küçük veya ona eşit N ile sınırlıdır, çünkü iki basamaklı sayılar popodaki ağrıdır.

EDIT: Ben onu emdi ve iki basamaklı sayılar için destek ekledim. Tek basamak için sıfır ile tuşlayın.

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

Perl, 27 bayt

İçin +1'i dahil et -p

Olarak çalıştırmak perl -p sdr.pl

STDIN'de verilen giriş, ilk satır dize, ikinci satır sayım Dize yalnızca "sözcük" karakterleri içerdiğini varsayar

sdr.pl:

eval's%\B.(.*).\B%$1%;'x<>

PHP, 60 bayt

Bu çözüm, karakterleri giriş dizgisinden karakterleri, dizine göre boş bir dizgiye ayarlar. Uzun bir süre önlemek için giriş dizesini doğrudan değiştiriyorum return.

function(&$w,$i){for(;$i;)$w[$i--]=$w[strlen($w)-$i-2]="";};

Temelde bellekte $wbitince şöyle görünür:

Addr 0 1 2 3 4
     H   l   o
     ^   ^   ^
>Result: Hlo

Bu şekilde koş:

php -r '$f = function(&$w,$i){for(;$i;)$w[$i--]=$w[strlen($w)-$i-2]="";}; $f($argv[1],$argv[2]);echo"$argv[1]\n";' Hello 1

Direkler , 16 Bayt.

i:At,{\,v\,v,A}c

Nasıl çalışır:

i    # Get command line input.
:At  # Set A equal to the top of the stack.
,    # Pop the stack.
{    # Start a for loop.
 \   # Swap the top two elements of the stack.
  ,  # Pop the stack.
   v # Reverse the stack.
 \   # Swap the top two elements of the stack.
  ,  # Pop the stack.
   v # Reverse the stack.
 ,   # Switch to loop iterations.
 A   # Iterate A times.
}    # End the for loop.
c    # Print the stack as a string

CJam, 15 bayt

r(\)\{(;);}ri*\

Eminim bu daha fazla golf oynamak mümkün ...

Jolf, 13 bayt

ΆFi liγhj_γgi

JavaScript cevabının bir çevirisi.

Açıklama:

ΆFi liγhj_γgi
Ά             ternary add
 Fi            i[0],
   `li         i sliced
      γhj       γ = j + 1
         _γ     to -γ
           gi  and the last of i

Burada dene!

Daha ilginç bir soru sonrası versiyonu:

 ΆFi]ihjYgi

Cidden, 17 bayt

,#,`p@pXod@dXq`nΣ

Girişi alır s \n n .

Çevrimiçi deneyin!

Açıklama:

,#,`p@pXod@dXq`nΣ
,#                 push a list of characters in s
  ,`          `n   do the following n times:
    p@pXo          pop 2 characters off the front, discard the second, put the first back
         d@dXq     pop 2 characters off the back, discard the second, put the first back
                Σ  join

C #, 129 bayt

Temelde 1'i atlayıp N'yi ve tersine çevrilmiş senaryoyu kaldırdığımızdan beri

string o(string i,int n){var s=i.ToList();int x=0;while(x<2){s.RemoveRange(1,n);s.Reverse();x++;}return new string(s.ToArray());}

ungolfed

string o(string i, int n)
{
    var s = i.ToList();
    int x = 0;
    while (x < 2) //Repeat the following twice
    {
        s.RemoveRange(1, n); //remove n at index 1
        s.Reverse(); //Reverse the list
        x++;
    }
    return new string(s.ToArray());
}

Java, 144 bayt

static String y(int i,String s){return i==0?s:y(i-1,new StringBuffer(s).replace(1,2,"").replace(s.length()-3,s.length()-2,"").toString());}