Intro

Nous avons eu des histogrammes et des comptages , mais pas tous.

Chaque année, Dyalog Ltd. organise un concours étudiant. Le défi consiste à écrire un bon code APL. Il s'agit d'une édition de code-golf indépendante du langage du sixième problème de cette année.

J'ai l'autorisation explicite de publier ce défi ici de l'auteur original du concours. N'hésitez pas à vérifier en suivant le lien fourni et en contactant l'auteur.

Problème

Le terme k-mer fait généralement référence à toutes les sous-chaînes possibles de longueur k contenues dans une chaîne. En génomique computationnelle, les k-mers font référence à toutes les sous-séquences possibles (de longueur k ) d'une lecture obtenue par séquençage d'ADN. Écrivez une fonction / programme qui prend une chaîne et k (la longueur de la sous-chaîne) et retourne / sort un vecteur des k-mers de la chaîne d'origine.

Exemples

[4,"ATCGAAGGTCGT"] → ["ATCG","TCGA","CGAA","GAAG","AAGG","AGGT","GGTC","GTCG","TCGT"]

k > longueur de chaîne? Ne rien retourner / aucun résultat vide:
[4,"AC"]→ []ou ""ou[""]

Gelée , 1 octet

ṡ

La gelée a un atome dyadique à un seul octet pour cette opération

Essayez-le en ligne!(le pied de page divise la liste résultante par des sauts de ligne, pour éviter l'impression d'une représentation musclée.)

Octave, 28 octets

@(N,s)s((1:N)+(0:nnz(s)-N)')

Essayez-le en ligne!

Pour k> la longueur de chaîne fonctionne dans les fenêtres Octave 4.2.1 mais dans tio (Octave 4.0.3) ne fonctionne pas.

Crée des index numériques d'éléments consécutifs et indexe la chaîne par elle.

s= "ATCGAAGGTCGT"
N = 4
idx = (1:N)+(0:nnz(s)-N)'
 =
    1    2    3    4
    2    3    4    5
    3    4    5    6
    4    5    6    7
    5    6    7    8
    6    7    8    9
    7    8    9   10
    8    9   10   11
    9   10   11   12

s(idx) =

ATCG
TCGA
CGAA
GAAG
AAGG
AGGT
GGTC
GTCG
TCGT

05AB1E , 2 octets

Code:

Ν

Explication:

Π     # Get all substrings of the input
 ù     # Only keep the substrings of length the second input

Utilise l' encodage 05AB1E .

Essayez-le en ligne!

C (GCC sur POSIX), 67 66 63 octets

-3 octets grâce à @LeakyNun!

f(i,s,j)char*s;{for(;j+i<=strlen(s);puts(""))write(1,s+j++,i);}

Essayez-le en ligne!

Brachylog , 3 octets

s₎ᶠ

Essayez-le en ligne!

Spécifications:

• Contribution: ["ATCGAAGGTCGT",4]
• Argument: Z
• Sortie: Z = ["ATCG","TCGA","CGAA","GAAG","AAGG","AGGT","GGTC","GTCG","TCGT"]

Comment ça marche

s₎ᶠ
s    Output is a substring of first element of input,
 ₎   with length specified by second element of input.
  ᶠ  Find all solutions.

Python 3 ,  47 45 42 octets

-3 octets grâce aux ovs (utilisez le déballage de Python 3 pour réutiliser a[n-1:]à la fin.)

f=lambda a,n:a[n-1:]and[a[:n],*f(a[1:],n)]

Une fonction récursive prenant la chaîne, aet la longueur de tranche n, et renvoyant une liste des tranches ou une chaîne vide.

a[n-1:]prend une tranche de la chaîne actuelle à partir du n-1 ^ème élément (indexé 0) pour tester s'il reste suffisamment d'éléments (une chaîne vide est falsey en Python) - c'est plus court que l'équivalent len(a)>=n.

• S'il y a suffisamment d' éléments d' une liste est construite, [...]avec les premiers néléments de la chaîne, a[:n]et le résultat décompressé d'appeler à nouveau la fonction, *f(...)avec une version dequeued de l'entrée actuelle (sans le premier élément), a[1:].

• S'il n'y a pas assez d'éléments, la queue de la récursivité est atteinte quand a[n-1:]est retournée (dans ce cas une chaîne vide).

Essayez-le en ligne!

45 pour Python 2 ou 3 avec:

f=lambda a,n:a[n-1:]and[a[:n]]+f(a[1:],n)or[]

J , 2 octets

,\

Ce n'est pas un programme complet, mais une fonction avec un opérateur.

Appelez-le comme tel:

echo 4 ,\ 'ATCGAAGGTCGT'

Essayez-le en ligne!

Comment ça marche

L'opérateur (appelé "conjonction") \(nommé " infix ") est utilisé comme tel:

(x u\ y)applique le verbe uaux parties successives de la liste y(appelées infixes).

La fonction (appelée "verbe") udans ce cas est la fonction ,qui est une simple fonction " ajouter ":

Crée un tableau contenant les éléments de xsuivis des éléments de y.

Mathematica, 21 octets

##~StringPartition~1&

Fonction anonyme. Prend une chaîne et un nombre (dans cet ordre) en entrée et renvoie une liste de chaînes en sortie.

R, 65 61 octets

-2 octets grâce à MickyT

-2 octets en modifiant l'indexation

renvoie une fonction anonyme.

function(s,n,x=nchar(s))`if`(n>x,'',substring(s,x:n-n+1,n:x))

substringfait défiler les indices (contrairement à substrce qui n'est pas le cas), et si l'indice de départ est inférieur à 1, il est par défaut1 place, il vérifie et renvoie la chaîne vide.

x:n-n+1est équivalent à 1:(x-n+1)puisque: a priorité sur les sommes / différences

Essayez-le en ligne!

Pyth , 2 octets

.:

Ce n'est pas un programme complet, mais une fonction intégrée.

Appelez-le comme tel:

.:"ATCGAAGGTCGT"4

Essayez-le en ligne!

Programme complet:

.:.*

Essayez-le en ligne!

(Le .*est splat.)

Méduse , 7 octets

p
_I
\i

Essayez-le en ligne!

Comment ça marche

En linéaire:, p(\(I,i))où pest imprimé et\ obtient les sous-chaînes requises.

I est la première entrée brute i la deuxième entrée évaluée.

Dans Jellyfish, chaque fonction et opérateur reçoit deux arguments, l'un à droite et l'autre à partir du bas. Ici, la fonction pobtient l'argument de la sortie de _, qui est nécessaire si nous voulons utiliser l'opérateur \pour obtenir des sous-chaînes.

Python 2 , 54 octets

lambda x,n:map(''.join,zip(*[x[b:]for b in range(n)]))

Essayez-le en ligne!

Java (OpenJDK 8) , 92 octets

void f(String s,int n){for(int i=n;i<=s.length();)System.out.println(s.substring(i-n,i++));}

Essayez-le en ligne!

Clojure, 19 octets

Eh bien c'est pratique:

#(partition % 1 %2)

Exemples:

(def f #(partition % 1 %2))
(println [(f 4 "ATCGAAGGTCGT")
          (f 4 "abc")])

[((A T C G) (T C G A) (C G A A) (G A A G) (A A G G) (A G G T) (G G T C) (G T C G) (T C G T))
 ()]

CJam , 4 octets

{ew}

Bloc anonyme qui attend les arguments sur la pile et laisse le résultat sur la pile après.

Essayez-le en ligne!

ew est un intégré qui fait exactement ce qui est nécessaire.

Rétine , 41 38 octets

.*$
$*
!&`(.)+(?=.*¶(?<-1>.)+(?(1)¶)$)

Essayez-le en ligne!

Prend la chaîne et compte sur des lignes séparées. Les deux premières lignes sont utilisées pour convertir le nombre de décimales en unaire, donc si une entrée unaire est acceptable, le nombre d'octets sera réduit à 34 31. Edit: 3 octets enregistrés grâce à @FryAmTheEggman. Ou, si vous préférez, une version de 48 octets qui gère les sauts de ligne dans la chaîne, bien que cela produise une sortie déroutante:

.*$
$*
!&`(\S|\s)+(?=[\S\s]*¶(?<-1>.)+(?(1)$.)$)

Octave avec paquet d'images, 29 octets

@(s,n)[im2col(+s, [1 n])' '']

Essayez-le en ligne!

Explication

La fonction im2col(m,b)prend une matrice m, en extrait des blocs de taille bet les arrange en colonnes. Par défaut, les blocs glissent (par opposition à distincts). Ici, la matrice mest un vecteur ligne des codes ASCII de la chaîne d'entrée s(cela se fait comme +s, ce qui est plus court que la norme double(s)), et la taille best [1 n]d'obtenir des blocs coulissants horizontalement den éléments .

Le résultat est transposé (en utilisant une transposition conjuguée complexe ', qui est plus courte que transposer .') pour transformer les colonnes en lignes, puis il est reconverti en char ( [... ''], qui est plus court que la norme char(...)).

oK, 2 octets

':

oK a un opérateur de fenêtre coulissante !

Python 3 , 49 octets

f=lambda a,n:[a[i:i+n]for i in range(len(a)-n+1)]

Essayez-le en ligne!

Une solution non récursive, quoique pas plus courte.

Compatible avec Python 2.

PHP, 75 octets

Version en ligne

for([,$n,$s]=$argv;$i+$n-1<strlen($s);)$r[]=substr($s,$i++,$n);print_r($r);

80 octets sans valeurs doubles

for([,$n,$s]=$argv;$i+$n-1<strlen($s);)$r[$p=substr($s,$i++,$n)]=$p;print_r($r);

Haskell, 39 octets

n#s|length s<n=[]|1<2=take n s:n#tail s

Exemple d'utilisation: 4 # "ABCDEF"-> ["ABCD","BCDE","CDEF"]. Essayez-le en ligne!

Une récursivité simple qui conserve les premiers ncaractères de la chaîne d'entrée et continue avec la queue de la chaîne tant que sa longueur n'est pas inférieure à n.

Microsoft Sql Server, 199 octets

create function dbo.f(@s nvarchar(max),@ int)returns table as return
with v as(select 2 p,left(@s,@)g where len(@s)>=@ union all
select p+1,substring(@s,p,@)from v where len(@s)>p-2+@)select g from v

Vérifie ça.

PowerShell, 70 octets

$b={$c,$s=$args;[regex]::matches($s,"(?=(.{$c}))")|%{''+$_.groups[1]}}

Essayez-le en ligne!

Empilé , 7 octets

infixes

Essayez-le en ligne!

Assez standard. Sans cette fonction intégrée, elle devient 20 octets:

{%x#'y-#+:>y#-#>x\#}

Lequel est:

{%x#'y-#+:>y#-#>x\#}
{%                 }   dyad; first arg: x, second arg: y
  x#'                  length of x (the array)
     y-                minus y (the skew)
       #+              plus 1
         :>            range [x, y]
           y#-         y minus 1
              #>       range from [[x, y], [x, y] + y]
                x\#    get indices from x

MATL , 3 octets

YC!

Essayez-le en ligne!

Explication

YC   % Sliding blocks of input string with input size, arranged as columns
!    % Transpose

C # 89 octets

void a(string s,int n){for(int i=n;i<=s.Length;)Console.WriteLine(s.Substring(i++-n,n));}

Essayez-le en ligne!

La meilleure méthode que j'ai pu trouver en C # est fondamentalement la même que Java

Rubis, 48 46 octets

->(s,k){0.upto(s.size-k).map{|i|s[i..i+k-1]}}

Aucune astuce particulière, juste un stabby-lambda définissant une fonction qui tire la sous-chaîne requise de chaque point de départ valide.

Enregistrement de deux octets, car il ne semble pas nécessaire de stocker le lambda.

V , 16 octets

òÀ|ly0Ïp
"_xòkVp

Pas terriblement bien joué, je le crains, j'ai du mal à "supprimer la chaîne si k> len (str)". L'entrée est dans le fichier, k est un argument. Jouer au golf avant l'explication

Essayez-le en ligne!

ML standard (mosml), 109 65 61 octets

fun f(n,x)=if n>length(x)then[]else List.take(x,n)::f(n,tl x)

Prend un nombre et une liste de caractères (une alternative assez courante aux chaînes dans le monde SML). (Fonctionne vraiment sur toutes les listes bien sûr.)

Usage:

- f(3,explode("ABCDEFGH"));
> val it =
    [[#"A", #"B", #"C"], [#"B", #"C", #"D"], [#"C", #"D", #"E"],
     [#"D", #"E", #"F"], [#"E", #"F", #"G"], [#"F", #"G", #"H"]] :
  char list list
- f(7, explode("ABCD"));
> val it = [] : char list list

Journal des modifications:

• À droite, il y a une bibliothèque standard .. (-44 octets)
• Changez la comparaison et zéro en [] comme suggéré (-4 octets)

JavaScript (Firefox 30-57), 51 octets

(s,n,t='')=>[for(c of s)if((t+=c)[n-1])t.slice(-n)]

64 octets dans ES6:

(s,n,t=s.slice(0,--n))=>[...s.slice(n)].map(c=>(t+=c).slice(~n))