Giới thiệu

Một từ viết tắt đệ quy là một từ viết tắt có chứa hoặc liên quan đến bản thân, ví dụ: Fishcó thể là một từ viết tắt đệ quy cho Fish is shiny hero, thông báo như thế nào mà cũng chứa các từ viết tắt riêng của mình. Một ví dụ khác là Hi-> Hi igloo. Hoặc thậm chí ppcg paints->ppcg paints cool galaxies pouring acid into night time stars

Về cơ bản, một câu là từ viết tắt đệ quy nếu các chữ cái đầu tiên của mỗi từ đánh vần từ hoặc từ đầu tiên.

Thử thách

Tạo một chương trình lấy một chuỗi từ 1 hoặc nhiều từ được phân tách bằng ký tự khoảng trắng và xuất ra từ viết tắt đệ quy hoặc chuỗi trống nếu không thể. Chẳng hạn, không thể tạo một từ viết tắt đệ quy cho một chuỗi như, ppcg elephantbởi vì bạn sẽ bắt đầu bằng cách lấy ptừ ppcgđó sau đó thêm từ đó vào từ viết tắt, sau đó lấy etừ elephant. Nhưng bây giờ chúng ta có một mâu thuẫn, vì từ viết tắt hiện đang phát âm là "pe ..", nó mâu thuẫn với "pp ..". Đó cũng là trường hợp với, ví dụ , hi. Bạn sẽ lấy htừ hi, nhưng câu đã kết thúc và không còn chữ nào để đánh vần nữa hivà chúng ta chỉ còn lại những từ hkhông khớphi. (Chuỗi cần một lượng từ lớn hơn hoặc bằng số lượng chữ cái trong từ viết tắt)

Đầu vào và đầu ra không phân biệt chữ hoa chữ thường

Những hạn chế

• Bất cứ điều gì nhập vào chương trình của bạn sẽ là những từ tiếng Anh hợp lệ. Nhưng bạn cũng phải đảm bảo xuất ra các từ tiếng Anh hợp lệ (bạn có thể sử dụng cơ sở dữ liệu hoặc chỉ lưu trữ một từ cho mỗi trong số 26 chữ cái)
• Các lỗ hổng tiêu chuẩn và quy tắc IO mặc định được áp dụng

Các trường hợp thử nghiệm

hi igloo -> hi
ppcg paints -> (impossible)
ppcg paints cool giraffes -> ppcg
ppcg paints cool galaxies pouring acid into night time stars -> ppcgpaints
ppcg paints cool galaxies pouring acid into night time -> ppcg
ppcg questions professional pool challengers greatly -> (impossible)
I -> I

Chấm điểm

Đây là môn đánh gôn , vì vậy mã nguồn nhỏ nhất tính bằng byte sẽ thắng

Japt , 13 byte

¸
mά
VøUÎ ©V

Hãy thử trực tuyến!

05AB1E , 16 byte

ð¡©ηʒJ®€нJηså}θJ

Hãy thử trực tuyến!

Haskell, 51 48 byte

Chỉnh sửa: -3 byte nhờ @xnor.

(\w->[r|p<-scanl1(++)w,map(!!0)w==p,r<-p]).words

Tìm từ viết tắt.

Hãy thử trực tuyến!

\w->            .words -- let 'w' be the input list split into words
   p<-scanl1(++)w      -- loop 'p' through the list starting with the first word
                       --  and appending the next words one by one, e.g.
                       --  "Fish","is","shiny","hero" -> "Fish","Fishis","Fishisshiny","Fishisshinyhero"
     ,map(!!0)w==p     -- if the word made out of the first characters of the
                       --  words of 'w' equal 'p'
  [r|   r<-p]          -- return the letters of 'p' - if the check before
                       --  never evaluates to True then no letters, i.e. the
                       --  the empty string is returned

Perl 6 , 50 42 58 49 byte

-9 byte nhờ nwellnhof

{~first {m:g/<<./.join~~/^$^a/},[R,] [\~] .words}

Hãy thử trực tuyến!

Lựa chọn đầu tiên. Tôi đang khai thác thực tế là ordchỉ trả về giá trị thứ tự của chữ cái đầu tiên của chuỗi, trong khi chrslấy danh sách các quỹ đạo và trả về một chuỗi. Hoặc regex từ câu trả lời của moonheart ngắn hơn :(. Để tham khảo, câu trả lời trước là .words>>.ord.chrsthay vì[~] m:g/<<./

Giải trình:

{~first {m:g/<<./.join~~/^$^a/},[R,] [\~] .words}
{                                               } # Anonymous code block
  first  # Find the first 
                                [R,] [\~] .words  # Of the reverse of the triangular joined words
         {                    }  # That matches:
          m:g/   /   # Match all from the original string
              <<.    # Single letters after a word boundary
                  .join    # Joined
                       ~~/^$^a/   # And starts with the given word
 ~  # And stringify Nil to an empty string

Võng mạc 0.8.2 , 60 byte

^
$'¶
\G(\w)\w* ?
$1
+`^(.+)(\w.*¶\1 )
$1 $2
!`^(.+)(?=¶\1 )

Hãy thử trực tuyến! Tìm các từ viết tắt đệ quy, nếu có. Giải trình:

^
$'¶

Nhân đôi đầu vào.

\G(\w)\w* ?
$1

Giảm các từ trên dòng đầu tiên thành chữ cái đầu tiên của chúng.

+`^(.+)(\w.*¶\1 )
$1 $2

Chèn khoảng trắng để khớp với các từ gốc, nếu có thể.

!`^(.+)(?=¶\1 )

Xuất ra dòng đầu tiên nếu nó là tiền tố của dòng thứ hai.

Perl 6 , 56 byte

$!=[~] m:g{<<.};say $! if m:g{<<\w+}.map({$_ eq $!}).any

Hãy thử trực tuyến!

Regexes trước đây là khó hiểu và không thể sử dụng với tôi. Đột nhiên tôi hiểu họ một cách hoàn hảo. Điều gì đã xảy ra với tôi: P

Hoàn thành lựa chọn 1.

K (ngn / k) , 40 byte

Lựa chọn đầu tiên:

{$[1=#:x;x;$[(*:t)~,/*:'t:" "\x;*:t;`]]}

Hãy thử trực tuyến!

Rust, 155, hãy thử trực tuyến!

Đã chọn: Bài toán 1: Tìm từ viết tắt

type S=String;fn f(t:&str)->S{let l=t.to_lowercase();let w=l.split(' ').fold(S::new(),|a,b|a+&b[..1])+" ";if (l+" ").contains(w.as_str()){w}else{S::new()}}

Ungolfed, chỉ một chút:

fn f(t: &str) -> String {
    let l = t.to_lowercase();
    let w = l.split(' ').fold(String::new(), |a, b| a + &b[0..1]) + " ";
    if (l + " ").contains(w.as_str()) {
        w
    } else {
        String::new()
    }
}

Hoặc nếu chúng ta có thể giả sử rằng đầu vào là chữ thường, chỉ 130:

type S=String;fn f(l:S)->S{let w=l.split(' ').fold(S::new(),|a,b|a+&b[..1])+" ";if (l+" ").contains(&w.as_str()){w}else{S::new()}}

Thạch , 9 byte

Ḳµ;\fZḢWƊ

Một chương trình in đầy đủ viết tắt đệ quy nếu có thể.

Hãy thử trực tuyến!

Làm sao?

Ḳµ;\fZḢWƊ - Main Link: list of characters
Ḳ         - split at space (let's call this v)
 µ        - start a new monadic chain (i.e. f(v)):
   \      - cumulative reduce v with:
  ;       -   concatenation -> [v(1), v(1);v(2), v(1);v(2);v(3); ...]
        Ɗ - last three links as a monad (i.e. f(v)):
     Z    -   transpose -> [[v(1)[1], v(2)[1], ...],[v(1)[1],v(2)[2],...],...]
      Ḣ   -   head -> [v(1)[1], v(2)[1], ...] ... i.e. 'the potential abbreviation'
       W  -   wrap in a list -> ['the potential abbreviation']
    f     - filter discard those from the left list that are not in the right list
          - implicit print -- a list of length 0 prints nothing
          -                   while a list of a single item prints that item

JavaScript [ES6], 74 byte

s=>s.split` `.map(w=>(b+='('+w,e+=')?',t+=w[0]),b=e=t='')&&t.match(b+e)[0]

Tạo một biểu thức chính quy để khớp. Xem ví dụ trong mã.

Tất cả các trường hợp thử nghiệm:

let f=

s=>s.split` `.map(w=>(b+='('+w,e+=')?',t+=w[0]),b=e=t='')&&t.match(b+e)[0]

console.log(f('hi igloo'))
// 'hi'.match('(hi(igloo)?)?')[0] == 'hi'

console.log(f('ppcg paints'))
// 'pp'.match('(ppcg(paints)?)?')[0] == ''

console.log(f('ppcg paints cool giraffes'))
// 'ppcg'.match('(ppcg(paints(cool(giraffes)?)?)?)?')[0] == 'ppcg'

console.log(f('ppcg paints cool galaxies pouring acid into night time stars'))
// 'ppcgpaints'.match('(ppcg(paints(cool(galaxies(pouring(acid(into(night(time(stars)?)?)?)?)?)?)?)?)?)?')[0] == 'ppcgpaints'

console.log(f('ppcg paints cool galaxies pouring acid into night time'))
// 'ppcgpaint'.match('(ppcg(paints(cool(galaxies(pouring(acid(into(night(time)?)?)?)?)?)?)?)?)?')[0] == 'ppcg'

console.log(f('ppcg questions professional pool challengers greatly'))
// 'pqppcg'.match('(ppcg(questions(professional(pool(challengers(greatly)?)?)?)?)?)?')[0] == ''

console.log(f('I'))
// 'I'.match('(I)?')[0] == 'I'

console.log(f('increase i'))
// 'ii'.match('(increase(i)?)?')[0] == ''

console.log(f('i increase'))
// 'ii'.match('(i(increase)?)?')[0] == 'i'

Python 2 , 106 byte

Tùy chọn đầu tiên - tìm từ viết tắt đệ quy.
Trả về kết quả trong danh sách.

I=input().split()
print[' '.join(I[:i])for i in range(1,-~len(I))if[j[0]for j in I]==list(''.join(I[:i]))]

Hãy thử trực tuyến!

Python 2 , 120 byte

Tùy chọn đầu tiên - tìm từ viết tắt đệ quy.

def F(I,a=[],r=''):
 for j in I.split():
  a+=j,
  if list(''.join(a))==[i[0]for i in I.split()]:r=' '.join(a)
 return r

Hãy thử trực tuyến!

Javascript, 71 byte

Cách tiếp cận 1

l=s=>{p=s.split(' ');k=p.reduce((r,x)=>r+x[0],'');return k==p[0]?k:''}

Ung dung:

l=s=>{
    p = s.split(' ');
    k = p.reduce((r,x)=>r+x[0],'');
    return k==p[0] ? k : '';
}

• Chia chuỗi theo không gian.
• Tạo chuỗi mới bằng cách lấy ký tự đầu tiên từ mỗi từ.
• So sánh nó với từ đầu tiên.

Ruby -apl , 57 byte

$_=y="";$F.all?{|w|$F.map(&:chr).join[/^#{y+=w}/]?$_=y:p}

Hãy thử trực tuyến!

Python 2 , 109 byte

def f(s,J=''.join):s=s.split();return[J(s[:i])for i in range(len(s)+1)if J(zip(*s)[0]).find(J(s[:i]))==0][-1]

Hãy thử trực tuyến!

Scala, 76 byte

Giải pháp cho trường hợp đơn giản (từ viết tắt không có khoảng trắng)

def^(s:String)={val l=s.split(" ");if(l(0)==l.map(_(0)).mkString)l(0)else""} 

Scala, 144 byte 100 byte (chỉ xem giải pháp của ASCII trong các bình luận)

def^(s:String)={val l=s.split(" ");l.scanLeft(List[String]())(_:::List(_)).find(_.mkString==l.map(_(0)).mkString).map(_.mkString).getOrElse("")}

Kiểm tra trong REPL

scala> def^(s:String)={val l=s.split(" ");if(l(0)==l.map(_(0)).mkString)l(0)else""}
$up: (s: String)String

scala> ^("hi igloo")
res12: String = hi

scala> ^("ppcg paints cool giraffes")
res13: String = ppcg

scala> ^("ppcg paints Xcool giraffes")
res14: String = ""

scala> ^("ppcg paints cool galaxies pouring acid into night time stars")
res15: String = ""

scala>

scala> def^(s:String)={val l=s.split(" ");l.scanLeft(List[String]())(_:::List(_)).find(_.mkString==l.map(_(0)).mkString).map(_.mkString).getOrElse("")}
$up: (s: String)String

scala> ^("hi igloo")
res16: String = hi

scala> ^("ppcg paints cool giraffes")
res17: String = ppcg

scala> ^("ppcg paints Xcool giraffes")
res18: String = ""

scala> ^("ppcg paints cool galaxies pouring acid into night time stars")
res19: String = ppcgpaints