Warning: session_start(): open(/var/lib/php/sessions/sess_c69u3djkm2qtqbdlc7e56msgp7, O_RDWR) failed: No space left on device (28) in /var/www/tb-usercake/models/config.php on line 51
Warning: session_start(): Failed to read session data: files (path: /var/lib/php/sessions) in /var/www/tb-usercake/models/config.php on line 51
import java.util.*;
import java.util.zip.*;
import java.util.List;
import java.util.regex.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.locks.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.table.*;
import java.io.*;
import java.net.*;
import java.lang.reflect.*;
import java.lang.ref.*;
import java.lang.management.*;
import java.security.*;
import java.security.spec.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.imageio.*;
import java.math.*;
// Calculates the fuzzy match of needle in haystack,
// using a modified version of the Levenshtein distance algorithm.
// ported from: http://ginstrom.com/scribbles/2007/12/01/fuzzy-substring-matching-with-levenshtein-distance-in-python/
class main {
static Pair levenSubstringIC_withIndex(String haystack, String needle) {
int m = strL(needle), n = strL(haystack);
// base cases
if (m == 1) {
int idx = indexOfIC(haystack, needle);
return idx < 0 ? pair(0, 1) : pair(idx, 0);
}
if (m == 0)
return pair(0, m);
int[] row1 = new int[n+1], row2 = new int[n+1];
for (int i = 0; i < m; i++) {
row2[0] = i+1;
for (int j = 0; j < n; j++) {
int cost = neqic(needle.charAt(i), haystack.charAt(j)) ? 1 : 0;
row2[j+1] = min3(row1[j+1]+1, // deletion
row2[j]+1, // insertion
row1[j]+cost); // substitution
}
int[] temp = row1;
row1 = row2;
row2 = temp;
}
Pair p = minOfIntArray_withIndex(row1);
return pair(max(0, p.a-m), p.b);
}
static int strL(String s) {
return s == null ? 0 : s.length();
}
static int indexOfIC(List a, String b) {
return indexOfIgnoreCase(a, b);
}
static int indexOfIC(List a, String b, int i) {
return indexOfIgnoreCase(a, b, i);
}
static int indexOfIC(String a, String b) {
return indexOfIgnoreCase(a, b);
}
static Pair pair(A a, B b) {
return new Pair(a, b);
}
static Pair pair(A a) {
return new Pair(a, a);
}
static boolean neqic(String a, String b) {
return !eqic(a, b);
}
static boolean neqic(char a, char b) {
return !eqic(a, b);
}
static int min3(int a, int b, int c) {
return min(min(a, b), c);
}
// return index and value
static Pair minOfIntArray_withIndex(int[] a) {
if (a == null || a.length == 0) return null;
int n = a.length, x = a[0], best = 0;
for (int i = 1; i < n; i++) {
int y = a[i];
if (y < x) {
x = y;
best = i;
}
}
return pair(best, x);
}
static int max(int a, int b) { return Math.max(a, b); }
static int max(int a, int b, int c) { return max(max(a, b), c); }
static long max(int a, long b) { return Math.max((long) a, b); }
static long max(long a, long b) { return Math.max(a, b); }
static double max(int a, double b) { return Math.max((double) a, b); }
static float max(float a, float b) { return Math.max(a, b); }
static double max(double a, double b) { return Math.max(a, b); }
static int max(Collection c) {
int x = Integer.MIN_VALUE;
for (int i : c) x = max(x, i);
return x;
}
static double max(double[] c) {
if (c.length == 0) return Double.MIN_VALUE;
double x = c[0];
for (int i = 1; i < c.length; i++) x = Math.max(x, c[i]);
return x;
}
static float max(float[] c) {
if (c.length == 0) return Float.MAX_VALUE;
float x = c[0];
for (int i = 1; i < c.length; i++) x = Math.max(x, c[i]);
return x;
}
static byte max(byte[] c) {
byte x = -128;
for (byte d : c) if (d > x) x = d;
return x;
}
static short max(short[] c) {
short x = -0x8000;
for (short d : c) if (d > x) x = d;
return x;
}
static int max(int[] c) {
int x = Integer.MIN_VALUE;
for (int d : c) if (d > x) x = d;
return x;
}
// works on lists and strings and null
static int indexOfIgnoreCase(List a, String b) {
return indexOfIgnoreCase(a, b, 0);
}
static int indexOfIgnoreCase(List a, String b, int i) {
int n = a == null ? 0 : a.size();
for (; i < n; i++)
if (eqic(a.get(i), b)) return i;
return -1;
}
static int indexOfIgnoreCase(String a, String b) {
return indexOfIgnoreCase_manual(a, b);
/*Matcher m = Pattern.compile(b, Pattern.CASE_INSENSITIVE + Pattern.LITERAL).matcher(a);
if (m.find()) return m.start(); else ret -1;*/
}
static boolean eqic(String a, String b) {
if ((a == null) != (b == null)) return false;
if (a == null) return true;
return a.equalsIgnoreCase(b);
}
static boolean eqic(char a, char b) {
if (a == b) return true;
char u1 = Character.toUpperCase(a);
char u2 = Character.toUpperCase(b);
if (u1 == u2) return true;
return Character.toLowerCase(u1) == Character.toLowerCase(u2);
}
static int min(int a, int b) {
return Math.min(a, b);
}
static long min(long a, long b) {
return Math.min(a, b);
}
static float min(float a, float b) { return Math.min(a, b); }
static float min(float a, float b, float c) { return min(min(a, b), c); }
static double min(double a, double b) {
return Math.min(a, b);
}
static double min(double[] c) {
double x = Double.MAX_VALUE;
for (double d : c) x = Math.min(x, d);
return x;
}
static float min(float[] c) {
float x = Float.MAX_VALUE;
for (float d : c) x = Math.min(x, d);
return x;
}
static byte min(byte[] c) {
byte x = 127;
for (byte d : c) if (d < x) x = d;
return x;
}
static short min(short[] c) {
short x = 0x7FFF;
for (short d : c) if (d < x) x = d;
return x;
}
static int min(int[] c) {
int x = Integer.MAX_VALUE;
for (int d : c) if (d < x) x = d;
return x;
}
static int indexOfIgnoreCase_manual(String a, String b) {
int la = strL(a), lb = strL(b);
if (la < lb) return -1;
int n = la-lb;
loop: for (int i = 0; i <= n; i++) {
for (int j = 0; j < lb; j++) {
char c1 = a.charAt(i+j), c2 = b.charAt(j);
if (!eqic(c1, c2))
continue loop;
}
return i;
}
return -1;
}
static boolean eq(Object a, Object b) {
return a == null ? b == null : a == b || b != null && a.equals(b);
}
static String asString(Object o) {
return o == null ? null : o.toString();
}
static String str(Object o) {
return o == null ? "null" : o.toString();
}
static String str(char[] c) {
return new String(c);
}
static class Pair implements Comparable> {
A a;
B b;
Pair() {}
Pair(A a, B b) {
this.b = b;
this.a = a;}
public int hashCode() {
return hashCodeFor(a) + 2*hashCodeFor(b);
}
public boolean equals(Object o) {
if (o == this) return true;
if (!(o instanceof Pair)) return false;
Pair t = (Pair) o;
return eq(a, t.a) && eq(b, t.b);
}
public String toString() {
return "<" + a + ", " + b + ">";
}
public int compareTo(Pair p) {
if (p == null) return 1;
int i = ((Comparable) a).compareTo(p.a);
if (i != 0) return i;
return ((Comparable) b).compareTo(p.b);
}
}
static int hashCodeFor(Object a) {
return a == null ? 0 : a.hashCode();
}
}