Meydan okuma

Boş polmayan bir giriş dizesi verildiğinde , kaynak kodundaki her bir karakterin ilk oluşumununs konumunu veren boş olmayan bir program / işlev yazın .sp

Örneğin, eğer programınız

main() { cout << magic << cin }
^0   ^5   ^10  ^15  ^20  ^25

ve bir girdi alır abcd{, çıktı

[1, x, 9, x, 7] (0-based)        [2, x, 10, x, 8] (1-based)

Burada, xbir karakter konumu için geçerli bir çıkış değil herhangi bir çıktı temsil eder (örneğin, negatif bir sayı, 0sen 1 tabanlı indeksleme kullanırsanız, NaN, Inf, dize potato, programınızın uzunluğundan daha büyük bir sayı, vs).

Kısıtlamalar

Kaynak kodun okunmasına izin verilmiyor (uygun bir sırada olduğu gibi). Yorumların kullanımına izin verilir, ancak puanınıza göre sayılır.

Girdi ve çıktı makul bir biçimde yapılabilir, ancak kesin olmalıdır (yalnızca ek sınırlayıcılar, randakış yok ve cevabın orada bir yerde olduğunu iddia eden), tutarlı (örneğin, xyukarıdaki değer her zaman aynı olmalıdır) ve insan- okunabilir ; örneğin, bir dize veya karakter dizisi. Girişin yazdırılabilir ASCII karakterlerinden oluşan bir dize (veya dizi) olduğunu varsayabilirsiniz; Unicode setinin tamamını kullanmanıza gerek yok.

Özel kod sayfası veya kodunuzda yazdırılamayan ascii?

Dil bir özel kod-sayfası (jöle APL, vs) kullanıyorsa, hesaba (bir program böylece atmalıdır €æÆzorunluluk çıkışı [1, x, 2]bir giriş için €%æ). -1Her zaman çıktı almak için yalnızca ASCII olmayan karakterleri kullanmak (giriş yalnızca ASCII olduğundan) geçerli bir çözüm değildir. Programınızın özel kod sayfanızı yerel olarak kabul ettiğini varsayabilirsiniz, yani programınız bir karakteri Abir tamsayıya dönüştürme yöntemine sahipse 65(ASCII kodlaması), kod sayfanızdaki 65. karakteri dönüştürdüğünü varsayabilirsiniz 65.

Aşağıdaki zorluktan ilham aldı: Konumsal Farkındalık

Python2, 55 Bayt

a=" )dfi(+m,nprut.';";print map(('a="'+a).find,input())

Kodda kullanılan tüm karakterleri içeren bir dize ile başlar ve sonra dizinleri arayın

Lenguage , 56.623 bayt

Aşağıda ilk 256 baytın altıgen bir dökümü bulunmaktadır. Kalan baytlar keyfi olarak seçilebilir.

0000000: 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f  ................
0000010: 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f  ................
0000020: 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f   !"#$%&'()*+,-./
0000030: 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f  0123456789:;<=>?
0000040: 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f  @ABCDEFGHIJKLMNO
0000050: 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f  PQRSTUVWXYZ[\]^_
0000060: 60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f  `abcdefghijklmno
0000070: 70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f  pqrstuvwxyz{|}~.
0000080: 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f  ................
0000090: 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f  ................
00000a0: a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af  ................
00000b0: b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf  ................
00000c0: c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ca cb cc cd ce cf  ................
00000d0: d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df  ................
00000e0: e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 ea eb ec ed ee ef  ................
00000f0: f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe ff  ................

Brainfuck ve ark.

Nasıl çalışır

Bu, özellikle basit bir kedi programıdır ,[.,].

Kaynak kod, sırayla tüm 256 bayt değerlerini içerir, bu nedenle her baytın içindeki dizini değeriyle eşleşir.

Lenguage , 1.22e7 bayt

Bayttan oluşur 12263215 NUL, (Hex 0x00) .

NULKaynakta görünmeyen her karakter için bir çıktılar .

Buradaki giriş, girişin hiçbir zaman a içermeyeceğidir NUL, bu yüzden NULgirişte karakter olan s miktarını her zaman çıkarırız.

Bu, aşağıdaki Brainfuck programına çevirir

,[[-].,]

Ve bir arıza ile ...

,[[-].,]
,[    ,]    #Basic Input loop.
  [-]       #Zero out the cell.
     .      #Print it (A NUL).

Bu sadece Lenguage'in bir golf dili olarak gücünü gösterir. Korku.

Jöle , 10 9 bayt

“ṾiЀƓv”v

Çevrimiçi deneyin!

Nasıl çalışır

“ṾiЀƓv”v  Main link. No arguments.

“ṾiЀƓv”   Set the left argument and the return value to s := 'ṾiЀƓv'.
        v  Execute the string s as a monadic Jelly program with argument s.

 Ṿ         Uneval; yield a string representation of s, i.e., r := '“ṾiЀƓv”'.
     Ɠ     Read one line from STDIN and evaluate it like Python would.
  iЀ      Find the index of each character in the input in r.
      v    Eval the list of indices as a monadic Jelly program with argument s.
           Why?
             This is the shortest way to add the character 'v' to the string s,
             meaning that we can use r without having to append anything.
           What?
             The v atom vectorizes at depth 1 for its left argument, meaning that
             it acts on arrays of numbers and/or characters. When fed an array of
             integers, it first converts them to strings, then concatenates the
             strings and evaluates them as a Jelly program. For example, the array
             [1, 2, 3] gets cast to the string '123', then evaluates, yielding 123.
             Something slightly different happens if the array starts with a 0. For
             example, the array [0, 1, 2] gets cast to '012' just as before, but
             Jelly views '0' and '12' as two separate tokens; numeric literals
             cannot start with a 0. Since the Jelly program is monadic, the first
             token – '0' – sets the return value to 0. Since the second token –
             '12' – is also a niladic link, the previous return value is printed
             before changing the return value to 12. Then, the program finishes
             and the last return value is printed implicitly.

pbrain, 402 356 340 338 329 bayt

[(:<>)+,-.](>>>>>>)+([-]<<[->+>+<<]>>[-<<+>>]>>[-<+<+>>]<[->+<]<[-<->]<)+([-]+++++++[>+++++++++++++<-]>)+([-]+++++[>++++++++<-]>)+(-:<+++[->++++++<]>)+(-:++)+(-:++)+(----:+)+(-:++)+(-:+)+(-:+)+(-:+)+([-]++:++)+([>[->+>+<<]>>[-<<+>>]<:>>+:[[-]>+<]>-[<<<<[-.>]>>>>>>+>>>>>]<<[-]<<+<-]>>>)[-]>>>>>>>,[<<<<<<++<+++++++++++++:>>>>>>,]

Phew, @KritixiLithos ve ben 4 gündür bunun üzerinde çalışıyoruz.

Baskılar 0x00giriş karakter programında değilse, komur göstergesi aksi hex (1 bazlı). Çevrimiçi deneyin!

Açıklama:

[(:<>)+,-.]
All chars listed here; like other submissions 
(>>>>>>)
@KritixiLithos added this part; I don't know what it does but saves the program
+([-]<<[->+>+<<]>>[-<<+>>]>>[-<+<+>>]<[->+<]<[-<->]<)
Comparison ;calculates z=x!=y and puts it in between x and y
Start; X _ _ _ Y
           ^
End;   X Z _ _ Y
         ^
+([-]+++++++[>+++++++++++++<-]>)
Function to add 91 to the tape
+([-]+++++[>++++++++<-]>)
Function to add 40 to the tape
+(-:<+++[->++++++<]>)
Function to add 58 to the tape
+(-:++)
Function to add 60 to the tape
+(-:++)
Function to add 62 to the tape
+(----:+)
Function to add 41 to the tape
+(-:++)
Function to add 43 to the tape
+(-:+)
Function to add 44 to the tape
+(-:+)
Function to add 45 to the tape
+(-:+)
Function to add 46 to the tape
+([-]++:++)
Function to add 93 to the tape
+([>[->+>+<<]>>[-<<+>>]<:>>+:[[-]>+<]>-[<‌​<<<[-.>]>>>>>>+>>>>>]<<[-]<<+<-]>>>)

Bu son fonksiyon döngüdür. Seçili karakterlere [(:<>)+,-.]sırayla girer ve girişi karakterle karşılaştırır. Şimdi bu döngünün nasıl çalıştığı hakkında daha derin bir açıklama yapacağım.

12-n n+2 _ n+2: _ _ _ i _ _ _ _ _ _;  n=loop counter
                  ^                ;  i=input

Yığın bir döngüdeyken böyle görünür. Döngü kadar devam edecek 12-nDİR 0. Sonra olan sayacı var n+2. Bu sayaç aynı zamanda seçilen karakterlerin her biri için fonksiyonun numarasıdır. Yani n=0, n+2yani ilk karakter, karşılık gelen edilecektir [. >[->+>+<<]>>[-<<+>>]<:sadece bunu yapar, sayacı karaktere çevirir.

İşaretçi, işaretin bulunduğu yere geldiğinde, sayaç değişkeninden üretilen karakteri, korunurken girişle karşılaştıracağız.

12-n n+2 _ n+2: Z _ _ i _ _ _ _ _ _;  n=loop counter
                ^                  ;  i=input

Zbir 0karakter girişi ya da başka başka bir sıfır olmayan tam sayıya eşit olduğu zaman.

Şimdi bu eşitliği kontrol etmek için bir if-ifadesi ile geldik.

[[-]>+<]

ZSıfır değilse , yani karakter ve giriş aynı değilse , bir sonraki hafıza yerini arttırırız.

Bu if ifadesinden çıktıktan sonra, bir sonraki hafıza yerini azaltacağız. Şimdi bu hafıza yeri içerir !Z. Sonunda bunu kullanarak karakterin indeksini girdiyle eşleşirse çıktılar ve sonra döngüden zorla çıkar. Aksi halde, bitene veya bir eşleşme bulunana kadar döngüye devam ederiz.

[-]>>>>>>>
Clears first byte; goes to position to start program
,[<<<<<<++<+++++++++++++:>>>>>>,]
Loops inputs

CJam , 14 12 bayt

{sq\f#p_~}_~

0 tabanlı dizinlemeyi ve -1kaynakta görünmeyen karakterleri kullanır .

Çevrimiçi deneyin!

Javascript, 34 bayt

f=a=>a.map(v=>('f='+f).indexOf(v))

Dizeleri bir dizi olarak girdi alır x, -1(0-tabanlı indeksleme).

C, 153 152 143 bayt

char s[99],p[]="odeflnrti%()*+-0;<={}\\";c;f(char*i){sprintf(s,"char s[99],p[]=\"%s",p);for(c=0;c<strlen(i);)printf("%d ",strchr(s,i[c++])-s);}

Çevrimiçi deneyin!

Ruby, 41 88 86 71 69 67 61 56 bayt

a='p$<.chrs{| #index};"';$<.chars{|c|p"a='#{a}".index c}

6 bayt öldürmek için Thx Lynn

> <> (Balık) 70 bayt

 #.0+4*a5;!?l|!?f4*b+l1--naolc3*1+0.01?!|~ed+0.0+2e-{:;!?+1:i-1:r}+2:"

Muhtemelen şimdiye kadar yaptığım en uzun> <> 1 astar.

Ayrı bir satırda bulunan her karakter için (0 dizinlenmiş) çıktı yazdıracaktır.

Bulunamayan bir karakter her zaman + 1 kodunun uzunluğunu yazdırır (bu geçerli durumdaysa tamam sayılırsa bunu değiştirebilirim), bu durumda 71 her zaman "Bulunamadı" karakterleri olur.

Vakti gelince bir açıklama yapacağım.

Bazı test durumları;

## K = 1 \ n1 \ n71

# "# = 1 \ n69 \ n1

Çevrimiçi deneyin

> <> dil

Perl 6 , 50 52 bayt

{(('R~.index$_) for}\\'R~'{((\'').index($_) for $_)}

GB'nin Ruby çözümü ve Rod's Python çözümü çevirisi .

Bir karakter listesi ve sıfır temelli indekslerin bir listesini çıkaran ( Nilolmayan karakterler için) bir lambda .

EDIT: Bir gözetim düzeltildi - 2 bayt eklenmesi gerekiyor :(

Clojure, 43 56 48 bayt

Düzenleme: Lanet olsun unuttum 2! 43'ten 56'ya yükseltildi.

Düzenleme 2: Bu metnin altındaki örnek kod güncellendi, eklenmeyen bayt sayısı güncellendi (def f ...), ancak karma harita kısmı.

{\{ 0\\   1\  3\0   4\1 10\3 14\4 20\2 34 \} 43}

Karma haritası yalnızca karakterlerden oluşur 01234{\\}ve konumlarını kodlar. Clojure'da karma haritalar, bu tam örnekte gösterildiği gibi fonksiyonlar kullanılabilir ( fkarma harita tanımıyla değiştirilebilir):

; Keeping track of the zero-based index:
;      00000000001111111111222222222233333333334444444444
;      01234567890123456789012345678901234567890123456789
(def f {\{ 0\\   1\  3\0   4\1 10\3 14\4 20\2 34 \} 43})

(map f "0123456789{} \\abcdef") ; (4 10 34 14 20 nil nil nil nil nil 0 43 3 1 nil nil nil nil nil nil)
(apply str (keys f))            ; " 01234{\\}"

Sanırım bu sayılır :)

JavaScript, 39 bayt

p=s=>[...s].map(c=>`p=${p}`.indexOf(c))

console.log( p('mapP') )

Pyth, 11 bayt

xL_+N"N+_Lx

Bir "quoted string"dizgideki herhangi bir alıntı ile bir öncekinden kaçan ve a kaynağında olmayan karakterlerle \sıfır dizine alınmış değerlerin bir listesini basan bir program -1.

Çevrimiçi deneyin!

Nasıl çalışır

xL_+N"N+_Lx    Program. Input: Q
xL_+N"N+_Lx"Q  Implicit quote closure and implicit input
     "N+_Lx"   Yield the string "N+_Lx"
   +N          Prepend a quote
  _            Reverse
 L          Q  Map over Q:
x               Yield the index of the character in the string
               Implicitly print

05AB1E , 19 bayt

"'ìsvDyk,"'"ìsvDyk,

Çevrimiçi deneyin!

Bu, eksik karakterlerin yerine -1 verir.

Luis Mendo bu Golf'ü (hafifçe değiştirilmiş) size büyük bir iyilik için Golf istedi! bu soruna "s" ve "k" eklenmesi de bu cevaba yol açar. Ancak, bir değişiklikten dolayı bu önemsiz şey için kredi alamam ... Luis, bunu tekrarlamak istersen bana mesaj gönderebilirsin ve ben sadece silerim. Bu soruyu bulmadan önce ilerleme durumumu görmek istiyorsanız, düzenlemeleri görüntüleyin. Eh ... O oldu bir noktada onunki gibi anlamlı.

SmileBASIC, 128 96 88 86 bayt

?R<3+CD,4LINPUT(S$)WHILE""<S$?INSTR("?R<3+CD,4LINPUT(S$)WHILE"+CHR$(34),SHIFT(S$))WEND

Gerçekleşmesi gereken önemli bir şey, bunun gerçekten de kısa bir zorluk olmadığıdır. Kaynak koduna yalnızca son benzersiz karaktere kadar ihtiyacınız var .

Kodun başına her karakterden en az 1 tanesini koydum: ?R<3+CD,4LINPUT(S$)WHILE"bu yüzden yalnızca programın bir kopyasını ilk tırnak işaretine kadar saklamak zorundayım.

Python, 90 88 bayt

a,b,d=" ()+.7:[]efilmnor","a,b,d=\"",lambda e:[[b.find(d),a.find(d)+7][d in a]for d in e]

Test durumu:

print(d("a,b(]q"))
#[0, 1, 2, 8, 15, -1]

Yığılmış , rekabet etmeyen, 36 bayt

Bu dilin hala geliştirilmediğini söylediğimde onu kastediyordum. Görünüşe göre, prompttüm yığını tüketmek için kullanılır. Bu yüzden hoş şeyler alamıyorum. Burada dene!

[tostr ':!' + prompt CS index out]:!

Bu standart quine çerçevesidir. Temel olarak, daha sonra birlikte çalıştırılan yığındaki :işlevi çoğaltır . Ardından, iç kısım yığındaki işlev ile birlikte çalışır. Onu bir dizgeye yayınlar, ekler (programın kendisi), sonra bir dize girdisi alır . karakter dizisine dönüştürür. Karakter dizgisi normalde dizgeden biraz farklıdır, çünkü üzerinde işleçleri vektörleştiriyor. Bu durumda, programda giriş dizesinin her bir dizinini veren ve sonunda yerleştirilen girdi üzerinden vektörleşir .[...]![...]:!promptCSindexout

Giriş için Hello, World!bu verir:

(-1 27 -1 -1 2 -1 6 -1 2 5 -1 26 9)

Birini kuyruğu olmadan kullanmayı denedim (yani kaynağınızda görünen karakter dizesini kodlamak gibi), ancak Stacked'de yalnızca bir tür tırnak işareti var ', bu nedenle bu tür bir çözümü yapmanız daha uzun olacaktır.

Kabuğu , 12 bayt

m€`:'""m€`:'

Çevrimiçi deneyin!

açıklama

Açıklama, ¨dizeleri sınırlandırmak ve 'karakterleri sınırlandırmak için kullanılıyor :

m€`:'""m€`:'  -- implicit input, for example: ¨m"a1`¨
      "m€`:'  -- string literal: ¨m€`:'¨
  `:'"        -- append character '"': ¨m€`:'"¨
m             -- map function over each character (example with 'a'):
 €            -- | index of first occurrence (1-indexed): 0
              -- : [1,6,0,0,3]

Java 8, 172 122 bayt

a->{/*.indexOf(c)+\" ;}orh:Systmup*/for(char c:a)System.out.print("a->{/*.indexOf(c)+\\\" ;}orh:Systmup".indexOf(c)+" ");}

0 dizinli ve -1kaynak kodunun bir parçası olmayan karakterler için verir .

Açıklama:

Çevrimiçi deneyin.

a->{                         // Method with character-array parameter and no return-type
  /*.indexOf(c)+\" ;}orh:Systmup*/
                             //  Comment containing the remaining characters of the code
  for(char c:a)              //  Loop over the input-array
    System.out.print(        //   Print:
      "a->{/*.indexOf(c)+\\\" ;}orh:Systmup"
                             //    String containing all the characters used in the code
      .indexOf(c)+" ");}     //    Print the index of the char, plus a space as delimiter

J , 31 22 bayt

11|1+i.~&'11|1+i.~&'''

Çevrimiçi deneyin!

1 indeksli, kodda bulunmayan karakterler için 0 ''tek bir teklif anlamına gelir. Dizedeki her karakteri bulun 11|1+i.~&', 1, modulo 11 ekleyin.

> <> , 31 bayt

'rd3*i:0(?;}{:}-&b0&?.75*l-nao]

Çevrimiçi deneyin!

Çıktı 1-indekslenmiştir, 32yani karakter kodda değildir.

Perl 5 ile -pl43 byte,

Yeni satır ayrılmış girişi kullanır -1ve programda görünmeyen karakterleri yazdırır .

$s=q{$_=index"\$s=q{$s};eval\$s",$_};eval$s

Çevrimiçi deneyin!

Stax , 19 bayt

"'sym[]I+"'"s+ym[]I

Koş ve hata ayıkla

Her satırda bir karakter olan 0 tabanlı dizini çıkarır. "34bL"34bLDaha önce yazdığım quine değiştirmekten daha kısa olduğu ortaya çıktı .